// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/vizier/services/metadata/metadatapb/service.proto

package metadatapb

import (
	bytes "bytes"
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
	distributedpb "px.dev/pixie/src/carnot/planner/distributedpb"
	logicalpb "px.dev/pixie/src/carnot/planner/dynamic_tracing/ir/logicalpb"
	statuspb "px.dev/pixie/src/common/base/statuspb"
	cvmsgspb "px.dev/pixie/src/shared/cvmsgspb"
	schemapb "px.dev/pixie/src/table_store/schemapb"
	messagespb "px.dev/pixie/src/vizier/messages/messagespb"
	agentpb "px.dev/pixie/src/vizier/services/shared/agentpb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type SchemaRequest struct {
}

func (m *SchemaRequest) Reset()      { *m = SchemaRequest{} }
func (*SchemaRequest) ProtoMessage() {}
func (*SchemaRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{0}
}
func (m *SchemaRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SchemaRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SchemaRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaRequest.Merge(m, src)
}
func (m *SchemaRequest) XXX_Size() int {
	return m.Size()
}
func (m *SchemaRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaRequest proto.InternalMessageInfo

type SchemaResponse struct {
	Schema *schemapb.Schema `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
}

func (m *SchemaResponse) Reset()      { *m = SchemaResponse{} }
func (*SchemaResponse) ProtoMessage() {}
func (*SchemaResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{1}
}
func (m *SchemaResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SchemaResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SchemaResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaResponse.Merge(m, src)
}
func (m *SchemaResponse) XXX_Size() int {
	return m.Size()
}
func (m *SchemaResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaResponse proto.InternalMessageInfo

func (m *SchemaResponse) GetSchema() *schemapb.Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

type AgentInfoRequest struct {
}

func (m *AgentInfoRequest) Reset()      { *m = AgentInfoRequest{} }
func (*AgentInfoRequest) ProtoMessage() {}
func (*AgentInfoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{2}
}
func (m *AgentInfoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentInfoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentInfoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentInfoRequest.Merge(m, src)
}
func (m *AgentInfoRequest) XXX_Size() int {
	return m.Size()
}
func (m *AgentInfoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentInfoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AgentInfoRequest proto.InternalMessageInfo

type AgentInfoResponse struct {
	Info []*AgentMetadata `protobuf:"bytes,1,rep,name=info,proto3" json:"info,omitempty"`
}

func (m *AgentInfoResponse) Reset()      { *m = AgentInfoResponse{} }
func (*AgentInfoResponse) ProtoMessage() {}
func (*AgentInfoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{3}
}
func (m *AgentInfoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentInfoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentInfoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentInfoResponse.Merge(m, src)
}
func (m *AgentInfoResponse) XXX_Size() int {
	return m.Size()
}
func (m *AgentInfoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentInfoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AgentInfoResponse proto.InternalMessageInfo

func (m *AgentInfoResponse) GetInfo() []*AgentMetadata {
	if m != nil {
		return m.Info
	}
	return nil
}

type AgentMetadata struct {
	Agent      *agentpb.Agent            `protobuf:"bytes,1,opt,name=agent,proto3" json:"agent,omitempty"`
	Status     *agentpb.AgentStatus      `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	CarnotInfo *distributedpb.CarnotInfo `protobuf:"bytes,3,opt,name=carnot_info,json=carnotInfo,proto3" json:"carnot_info,omitempty"`
}

func (m *AgentMetadata) Reset()      { *m = AgentMetadata{} }
func (*AgentMetadata) ProtoMessage() {}
func (*AgentMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{4}
}
func (m *AgentMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentMetadata.Merge(m, src)
}
func (m *AgentMetadata) XXX_Size() int {
	return m.Size()
}
func (m *AgentMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_AgentMetadata proto.InternalMessageInfo

func (m *AgentMetadata) GetAgent() *agentpb.Agent {
	if m != nil {
		return m.Agent
	}
	return nil
}

func (m *AgentMetadata) GetStatus() *agentpb.AgentStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *AgentMetadata) GetCarnotInfo() *distributedpb.CarnotInfo {
	if m != nil {
		return m.CarnotInfo
	}
	return nil
}

type AgentUpdatesRequest struct {
	MaxUpdateInterval     *types.Duration `protobuf:"bytes,1,opt,name=max_update_interval,json=maxUpdateInterval,proto3" json:"max_update_interval,omitempty"`
	MaxUpdatesPerResponse int32           `protobuf:"varint,2,opt,name=max_updates_per_response,json=maxUpdatesPerResponse,proto3" json:"max_updates_per_response,omitempty"`
}

func (m *AgentUpdatesRequest) Reset()      { *m = AgentUpdatesRequest{} }
func (*AgentUpdatesRequest) ProtoMessage() {}
func (*AgentUpdatesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{5}
}
func (m *AgentUpdatesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentUpdatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentUpdatesRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentUpdatesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentUpdatesRequest.Merge(m, src)
}
func (m *AgentUpdatesRequest) XXX_Size() int {
	return m.Size()
}
func (m *AgentUpdatesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentUpdatesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AgentUpdatesRequest proto.InternalMessageInfo

func (m *AgentUpdatesRequest) GetMaxUpdateInterval() *types.Duration {
	if m != nil {
		return m.MaxUpdateInterval
	}
	return nil
}

func (m *AgentUpdatesRequest) GetMaxUpdatesPerResponse() int32 {
	if m != nil {
		return m.MaxUpdatesPerResponse
	}
	return 0
}

type AgentUpdate struct {
	AgentID *uuidpb.UUID `protobuf:"bytes,1,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
	// Types that are valid to be assigned to Update:
	//	*AgentUpdate_Deleted
	//	*AgentUpdate_Agent
	//	*AgentUpdate_DataInfo
	Update isAgentUpdate_Update `protobuf_oneof:"update"`
}

func (m *AgentUpdate) Reset()      { *m = AgentUpdate{} }
func (*AgentUpdate) ProtoMessage() {}
func (*AgentUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{6}
}
func (m *AgentUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentUpdate.Merge(m, src)
}
func (m *AgentUpdate) XXX_Size() int {
	return m.Size()
}
func (m *AgentUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_AgentUpdate proto.InternalMessageInfo

type isAgentUpdate_Update interface {
	isAgentUpdate_Update()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type AgentUpdate_Deleted struct {
	Deleted bool `protobuf:"varint,2,opt,name=deleted,proto3,oneof" json:"deleted,omitempty"`
}
type AgentUpdate_Agent struct {
	Agent *agentpb.Agent `protobuf:"bytes,3,opt,name=agent,proto3,oneof" json:"agent,omitempty"`
}
type AgentUpdate_DataInfo struct {
	DataInfo *messagespb.AgentDataInfo `protobuf:"bytes,4,opt,name=data_info,json=dataInfo,proto3,oneof" json:"data_info,omitempty"`
}

func (*AgentUpdate_Deleted) isAgentUpdate_Update()  {}
func (*AgentUpdate_Agent) isAgentUpdate_Update()    {}
func (*AgentUpdate_DataInfo) isAgentUpdate_Update() {}

func (m *AgentUpdate) GetUpdate() isAgentUpdate_Update {
	if m != nil {
		return m.Update
	}
	return nil
}

func (m *AgentUpdate) GetAgentID() *uuidpb.UUID {
	if m != nil {
		return m.AgentID
	}
	return nil
}

func (m *AgentUpdate) GetDeleted() bool {
	if x, ok := m.GetUpdate().(*AgentUpdate_Deleted); ok {
		return x.Deleted
	}
	return false
}

func (m *AgentUpdate) GetAgent() *agentpb.Agent {
	if x, ok := m.GetUpdate().(*AgentUpdate_Agent); ok {
		return x.Agent
	}
	return nil
}

func (m *AgentUpdate) GetDataInfo() *messagespb.AgentDataInfo {
	if x, ok := m.GetUpdate().(*AgentUpdate_DataInfo); ok {
		return x.DataInfo
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AgentUpdate) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AgentUpdate_Deleted)(nil),
		(*AgentUpdate_Agent)(nil),
		(*AgentUpdate_DataInfo)(nil),
	}
}

type AgentUpdatesResponse struct {
	AgentUpdates        []*AgentUpdate              `protobuf:"bytes,1,rep,name=agent_updates,json=agentUpdates,proto3" json:"agent_updates,omitempty"`
	AgentSchemas        []*distributedpb.SchemaInfo `protobuf:"bytes,2,rep,name=agent_schemas,json=agentSchemas,proto3" json:"agent_schemas,omitempty"`
	AgentSchemasUpdated bool                        `protobuf:"varint,3,opt,name=agent_schemas_updated,json=agentSchemasUpdated,proto3" json:"agent_schemas_updated,omitempty"`
	EndOfVersion        bool                        `protobuf:"varint,4,opt,name=end_of_version,json=endOfVersion,proto3" json:"end_of_version,omitempty"`
}

func (m *AgentUpdatesResponse) Reset()      { *m = AgentUpdatesResponse{} }
func (*AgentUpdatesResponse) ProtoMessage() {}
func (*AgentUpdatesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{7}
}
func (m *AgentUpdatesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentUpdatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentUpdatesResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentUpdatesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentUpdatesResponse.Merge(m, src)
}
func (m *AgentUpdatesResponse) XXX_Size() int {
	return m.Size()
}
func (m *AgentUpdatesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentUpdatesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AgentUpdatesResponse proto.InternalMessageInfo

func (m *AgentUpdatesResponse) GetAgentUpdates() []*AgentUpdate {
	if m != nil {
		return m.AgentUpdates
	}
	return nil
}

func (m *AgentUpdatesResponse) GetAgentSchemas() []*distributedpb.SchemaInfo {
	if m != nil {
		return m.AgentSchemas
	}
	return nil
}

func (m *AgentUpdatesResponse) GetAgentSchemasUpdated() bool {
	if m != nil {
		return m.AgentSchemasUpdated
	}
	return false
}

func (m *AgentUpdatesResponse) GetEndOfVersion() bool {
	if m != nil {
		return m.EndOfVersion
	}
	return false
}

type WithPrefixKeyRequest struct {
	Prefix string `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proto  string `protobuf:"bytes,2,opt,name=proto,proto3" json:"proto,omitempty"`
}

func (m *WithPrefixKeyRequest) Reset()      { *m = WithPrefixKeyRequest{} }
func (*WithPrefixKeyRequest) ProtoMessage() {}
func (*WithPrefixKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{8}
}
func (m *WithPrefixKeyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WithPrefixKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WithPrefixKeyRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WithPrefixKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WithPrefixKeyRequest.Merge(m, src)
}
func (m *WithPrefixKeyRequest) XXX_Size() int {
	return m.Size()
}
func (m *WithPrefixKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_WithPrefixKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_WithPrefixKeyRequest proto.InternalMessageInfo

func (m *WithPrefixKeyRequest) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *WithPrefixKeyRequest) GetProto() string {
	if m != nil {
		return m.Proto
	}
	return ""
}

type WithPrefixKeyResponse struct {
	Kvs []*WithPrefixKeyResponse_KV `protobuf:"bytes,1,rep,name=kvs,proto3" json:"kvs,omitempty"`
}

func (m *WithPrefixKeyResponse) Reset()      { *m = WithPrefixKeyResponse{} }
func (*WithPrefixKeyResponse) ProtoMessage() {}
func (*WithPrefixKeyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{9}
}
func (m *WithPrefixKeyResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WithPrefixKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WithPrefixKeyResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WithPrefixKeyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WithPrefixKeyResponse.Merge(m, src)
}
func (m *WithPrefixKeyResponse) XXX_Size() int {
	return m.Size()
}
func (m *WithPrefixKeyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_WithPrefixKeyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_WithPrefixKeyResponse proto.InternalMessageInfo

func (m *WithPrefixKeyResponse) GetKvs() []*WithPrefixKeyResponse_KV {
	if m != nil {
		return m.Kvs
	}
	return nil
}

type WithPrefixKeyResponse_KV struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *WithPrefixKeyResponse_KV) Reset()      { *m = WithPrefixKeyResponse_KV{} }
func (*WithPrefixKeyResponse_KV) ProtoMessage() {}
func (*WithPrefixKeyResponse_KV) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{9, 0}
}
func (m *WithPrefixKeyResponse_KV) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WithPrefixKeyResponse_KV) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WithPrefixKeyResponse_KV.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WithPrefixKeyResponse_KV) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WithPrefixKeyResponse_KV.Merge(m, src)
}
func (m *WithPrefixKeyResponse_KV) XXX_Size() int {
	return m.Size()
}
func (m *WithPrefixKeyResponse_KV) XXX_DiscardUnknown() {
	xxx_messageInfo_WithPrefixKeyResponse_KV.DiscardUnknown(m)
}

var xxx_messageInfo_WithPrefixKeyResponse_KV proto.InternalMessageInfo

func (m *WithPrefixKeyResponse_KV) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *WithPrefixKeyResponse_KV) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type RegisterTracepointRequest struct {
	Requests []*RegisterTracepointRequest_TracepointRequest `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"`
}

func (m *RegisterTracepointRequest) Reset()      { *m = RegisterTracepointRequest{} }
func (*RegisterTracepointRequest) ProtoMessage() {}
func (*RegisterTracepointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{10}
}
func (m *RegisterTracepointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTracepointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTracepointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTracepointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTracepointRequest.Merge(m, src)
}
func (m *RegisterTracepointRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterTracepointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTracepointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTracepointRequest proto.InternalMessageInfo

func (m *RegisterTracepointRequest) GetRequests() []*RegisterTracepointRequest_TracepointRequest {
	if m != nil {
		return m.Requests
	}
	return nil
}

type RegisterTracepointRequest_TracepointRequest struct {
	TracepointDeployment *logicalpb.TracepointDeployment `protobuf:"bytes,1,opt,name=tracepoint_deployment,json=tracepointDeployment,proto3" json:"tracepoint_deployment,omitempty"`
	Name                 string                          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	TTL                  *types.Duration                 `protobuf:"bytes,3,opt,name=ttl,proto3" json:"ttl,omitempty"`
}

func (m *RegisterTracepointRequest_TracepointRequest) Reset() {
	*m = RegisterTracepointRequest_TracepointRequest{}
}
func (*RegisterTracepointRequest_TracepointRequest) ProtoMessage() {}
func (*RegisterTracepointRequest_TracepointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{10, 0}
}
func (m *RegisterTracepointRequest_TracepointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTracepointRequest_TracepointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTracepointRequest_TracepointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTracepointRequest_TracepointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTracepointRequest_TracepointRequest.Merge(m, src)
}
func (m *RegisterTracepointRequest_TracepointRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterTracepointRequest_TracepointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTracepointRequest_TracepointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTracepointRequest_TracepointRequest proto.InternalMessageInfo

func (m *RegisterTracepointRequest_TracepointRequest) GetTracepointDeployment() *logicalpb.TracepointDeployment {
	if m != nil {
		return m.TracepointDeployment
	}
	return nil
}

func (m *RegisterTracepointRequest_TracepointRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RegisterTracepointRequest_TracepointRequest) GetTTL() *types.Duration {
	if m != nil {
		return m.TTL
	}
	return nil
}

type RegisterTracepointResponse struct {
	Tracepoints []*RegisterTracepointResponse_TracepointStatus `protobuf:"bytes,1,rep,name=tracepoints,proto3" json:"tracepoints,omitempty"`
	Status      *statuspb.Status                               `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *RegisterTracepointResponse) Reset()      { *m = RegisterTracepointResponse{} }
func (*RegisterTracepointResponse) ProtoMessage() {}
func (*RegisterTracepointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{11}
}
func (m *RegisterTracepointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTracepointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTracepointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTracepointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTracepointResponse.Merge(m, src)
}
func (m *RegisterTracepointResponse) XXX_Size() int {
	return m.Size()
}
func (m *RegisterTracepointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTracepointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTracepointResponse proto.InternalMessageInfo

func (m *RegisterTracepointResponse) GetTracepoints() []*RegisterTracepointResponse_TracepointStatus {
	if m != nil {
		return m.Tracepoints
	}
	return nil
}

func (m *RegisterTracepointResponse) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type RegisterTracepointResponse_TracepointStatus struct {
	Status *statuspb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	ID     *uuidpb.UUID     `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Name   string           `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *RegisterTracepointResponse_TracepointStatus) Reset() {
	*m = RegisterTracepointResponse_TracepointStatus{}
}
func (*RegisterTracepointResponse_TracepointStatus) ProtoMessage() {}
func (*RegisterTracepointResponse_TracepointStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{11, 0}
}
func (m *RegisterTracepointResponse_TracepointStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTracepointResponse_TracepointStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTracepointResponse_TracepointStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTracepointResponse_TracepointStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTracepointResponse_TracepointStatus.Merge(m, src)
}
func (m *RegisterTracepointResponse_TracepointStatus) XXX_Size() int {
	return m.Size()
}
func (m *RegisterTracepointResponse_TracepointStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTracepointResponse_TracepointStatus.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTracepointResponse_TracepointStatus proto.InternalMessageInfo

func (m *RegisterTracepointResponse_TracepointStatus) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *RegisterTracepointResponse_TracepointStatus) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *RegisterTracepointResponse_TracepointStatus) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type GetTracepointInfoRequest struct {
	IDs []*uuidpb.UUID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

func (m *GetTracepointInfoRequest) Reset()      { *m = GetTracepointInfoRequest{} }
func (*GetTracepointInfoRequest) ProtoMessage() {}
func (*GetTracepointInfoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{12}
}
func (m *GetTracepointInfoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTracepointInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTracepointInfoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTracepointInfoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTracepointInfoRequest.Merge(m, src)
}
func (m *GetTracepointInfoRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetTracepointInfoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTracepointInfoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTracepointInfoRequest proto.InternalMessageInfo

func (m *GetTracepointInfoRequest) GetIDs() []*uuidpb.UUID {
	if m != nil {
		return m.IDs
	}
	return nil
}

type GetTracepointInfoResponse struct {
	Tracepoints []*GetTracepointInfoResponse_TracepointState `protobuf:"bytes,1,rep,name=tracepoints,proto3" json:"tracepoints,omitempty"`
}

func (m *GetTracepointInfoResponse) Reset()      { *m = GetTracepointInfoResponse{} }
func (*GetTracepointInfoResponse) ProtoMessage() {}
func (*GetTracepointInfoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{13}
}
func (m *GetTracepointInfoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTracepointInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTracepointInfoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTracepointInfoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTracepointInfoResponse.Merge(m, src)
}
func (m *GetTracepointInfoResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetTracepointInfoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTracepointInfoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTracepointInfoResponse proto.InternalMessageInfo

func (m *GetTracepointInfoResponse) GetTracepoints() []*GetTracepointInfoResponse_TracepointState {
	if m != nil {
		return m.Tracepoints
	}
	return nil
}

type GetTracepointInfoResponse_TracepointState struct {
	ID            *uuidpb.UUID            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State         statuspb.LifeCycleState `protobuf:"varint,2,opt,name=state,proto3,enum=px.statuspb.LifeCycleState" json:"state,omitempty"`
	Statuses      []*statuspb.Status      `protobuf:"bytes,3,rep,name=statuses,proto3" json:"statuses,omitempty"`
	Name          string                  `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	ExpectedState statuspb.LifeCycleState `protobuf:"varint,5,opt,name=expected_state,json=expectedState,proto3,enum=px.statuspb.LifeCycleState" json:"expected_state,omitempty"`
	SchemaNames   []string                `protobuf:"bytes,6,rep,name=schema_names,json=schemaNames,proto3" json:"schema_names,omitempty"`
}

func (m *GetTracepointInfoResponse_TracepointState) Reset() {
	*m = GetTracepointInfoResponse_TracepointState{}
}
func (*GetTracepointInfoResponse_TracepointState) ProtoMessage() {}
func (*GetTracepointInfoResponse_TracepointState) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{13, 0}
}
func (m *GetTracepointInfoResponse_TracepointState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTracepointInfoResponse_TracepointState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTracepointInfoResponse_TracepointState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTracepointInfoResponse_TracepointState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTracepointInfoResponse_TracepointState.Merge(m, src)
}
func (m *GetTracepointInfoResponse_TracepointState) XXX_Size() int {
	return m.Size()
}
func (m *GetTracepointInfoResponse_TracepointState) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTracepointInfoResponse_TracepointState.DiscardUnknown(m)
}

var xxx_messageInfo_GetTracepointInfoResponse_TracepointState proto.InternalMessageInfo

func (m *GetTracepointInfoResponse_TracepointState) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *GetTracepointInfoResponse_TracepointState) GetState() statuspb.LifeCycleState {
	if m != nil {
		return m.State
	}
	return statuspb.UNKNOWN_STATE
}

func (m *GetTracepointInfoResponse_TracepointState) GetStatuses() []*statuspb.Status {
	if m != nil {
		return m.Statuses
	}
	return nil
}

func (m *GetTracepointInfoResponse_TracepointState) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GetTracepointInfoResponse_TracepointState) GetExpectedState() statuspb.LifeCycleState {
	if m != nil {
		return m.ExpectedState
	}
	return statuspb.UNKNOWN_STATE
}

func (m *GetTracepointInfoResponse_TracepointState) GetSchemaNames() []string {
	if m != nil {
		return m.SchemaNames
	}
	return nil
}

type RemoveTracepointRequest struct {
	Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
}

func (m *RemoveTracepointRequest) Reset()      { *m = RemoveTracepointRequest{} }
func (*RemoveTracepointRequest) ProtoMessage() {}
func (*RemoveTracepointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{14}
}
func (m *RemoveTracepointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveTracepointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveTracepointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveTracepointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveTracepointRequest.Merge(m, src)
}
func (m *RemoveTracepointRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveTracepointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveTracepointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveTracepointRequest proto.InternalMessageInfo

func (m *RemoveTracepointRequest) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

type RemoveTracepointResponse struct {
	Status *statuspb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *RemoveTracepointResponse) Reset()      { *m = RemoveTracepointResponse{} }
func (*RemoveTracepointResponse) ProtoMessage() {}
func (*RemoveTracepointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{15}
}
func (m *RemoveTracepointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveTracepointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveTracepointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveTracepointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveTracepointResponse.Merge(m, src)
}
func (m *RemoveTracepointResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveTracepointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveTracepointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveTracepointResponse proto.InternalMessageInfo

func (m *RemoveTracepointResponse) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type UpdateConfigRequest struct {
	Key          string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value        string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	AgentPodName string `protobuf:"bytes,3,opt,name=agent_pod_name,json=agentPodName,proto3" json:"agent_pod_name,omitempty"`
}

func (m *UpdateConfigRequest) Reset()      { *m = UpdateConfigRequest{} }
func (*UpdateConfigRequest) ProtoMessage() {}
func (*UpdateConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{16}
}
func (m *UpdateConfigRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateConfigRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateConfigRequest.Merge(m, src)
}
func (m *UpdateConfigRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateConfigRequest proto.InternalMessageInfo

func (m *UpdateConfigRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *UpdateConfigRequest) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *UpdateConfigRequest) GetAgentPodName() string {
	if m != nil {
		return m.AgentPodName
	}
	return ""
}

type UpdateConfigResponse struct {
	Status *statuspb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *UpdateConfigResponse) Reset()      { *m = UpdateConfigResponse{} }
func (*UpdateConfigResponse) ProtoMessage() {}
func (*UpdateConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{17}
}
func (m *UpdateConfigResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateConfigResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateConfigResponse.Merge(m, src)
}
func (m *UpdateConfigResponse) XXX_Size() int {
	return m.Size()
}
func (m *UpdateConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateConfigResponse proto.InternalMessageInfo

func (m *UpdateConfigResponse) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type GetScriptsRequest struct {
}

func (m *GetScriptsRequest) Reset()      { *m = GetScriptsRequest{} }
func (*GetScriptsRequest) ProtoMessage() {}
func (*GetScriptsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{18}
}
func (m *GetScriptsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptsRequest.Merge(m, src)
}
func (m *GetScriptsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptsRequest proto.InternalMessageInfo

type GetScriptsResponse struct {
	Scripts map[string]*cvmsgspb.CronScript `protobuf:"bytes,1,rep,name=scripts,proto3" json:"scripts,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *GetScriptsResponse) Reset()      { *m = GetScriptsResponse{} }
func (*GetScriptsResponse) ProtoMessage() {}
func (*GetScriptsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{19}
}
func (m *GetScriptsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptsResponse.Merge(m, src)
}
func (m *GetScriptsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptsResponse proto.InternalMessageInfo

func (m *GetScriptsResponse) GetScripts() map[string]*cvmsgspb.CronScript {
	if m != nil {
		return m.Scripts
	}
	return nil
}

type AddOrUpdateScriptRequest struct {
	Script *cvmsgspb.CronScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"`
}

func (m *AddOrUpdateScriptRequest) Reset()      { *m = AddOrUpdateScriptRequest{} }
func (*AddOrUpdateScriptRequest) ProtoMessage() {}
func (*AddOrUpdateScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{20}
}
func (m *AddOrUpdateScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddOrUpdateScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddOrUpdateScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddOrUpdateScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddOrUpdateScriptRequest.Merge(m, src)
}
func (m *AddOrUpdateScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddOrUpdateScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddOrUpdateScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddOrUpdateScriptRequest proto.InternalMessageInfo

func (m *AddOrUpdateScriptRequest) GetScript() *cvmsgspb.CronScript {
	if m != nil {
		return m.Script
	}
	return nil
}

type AddOrUpdateScriptResponse struct {
}

func (m *AddOrUpdateScriptResponse) Reset()      { *m = AddOrUpdateScriptResponse{} }
func (*AddOrUpdateScriptResponse) ProtoMessage() {}
func (*AddOrUpdateScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{21}
}
func (m *AddOrUpdateScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddOrUpdateScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddOrUpdateScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddOrUpdateScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddOrUpdateScriptResponse.Merge(m, src)
}
func (m *AddOrUpdateScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddOrUpdateScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddOrUpdateScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddOrUpdateScriptResponse proto.InternalMessageInfo

type DeleteScriptRequest struct {
	ScriptID *uuidpb.UUID `protobuf:"bytes,1,opt,name=script_id,json=scriptId,proto3" json:"script_id,omitempty"`
}

func (m *DeleteScriptRequest) Reset()      { *m = DeleteScriptRequest{} }
func (*DeleteScriptRequest) ProtoMessage() {}
func (*DeleteScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{22}
}
func (m *DeleteScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteScriptRequest.Merge(m, src)
}
func (m *DeleteScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteScriptRequest proto.InternalMessageInfo

func (m *DeleteScriptRequest) GetScriptID() *uuidpb.UUID {
	if m != nil {
		return m.ScriptID
	}
	return nil
}

type DeleteScriptResponse struct {
}

func (m *DeleteScriptResponse) Reset()      { *m = DeleteScriptResponse{} }
func (*DeleteScriptResponse) ProtoMessage() {}
func (*DeleteScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{23}
}
func (m *DeleteScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteScriptResponse.Merge(m, src)
}
func (m *DeleteScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteScriptResponse proto.InternalMessageInfo

type SetScriptsRequest struct {
	Scripts map[string]*cvmsgspb.CronScript `protobuf:"bytes,1,rep,name=scripts,proto3" json:"scripts,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *SetScriptsRequest) Reset()      { *m = SetScriptsRequest{} }
func (*SetScriptsRequest) ProtoMessage() {}
func (*SetScriptsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{24}
}
func (m *SetScriptsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetScriptsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetScriptsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetScriptsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetScriptsRequest.Merge(m, src)
}
func (m *SetScriptsRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetScriptsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetScriptsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetScriptsRequest proto.InternalMessageInfo

func (m *SetScriptsRequest) GetScripts() map[string]*cvmsgspb.CronScript {
	if m != nil {
		return m.Scripts
	}
	return nil
}

type SetScriptsResponse struct {
}

func (m *SetScriptsResponse) Reset()      { *m = SetScriptsResponse{} }
func (*SetScriptsResponse) ProtoMessage() {}
func (*SetScriptsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{25}
}
func (m *SetScriptsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetScriptsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetScriptsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetScriptsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetScriptsResponse.Merge(m, src)
}
func (m *SetScriptsResponse) XXX_Size() int {
	return m.Size()
}
func (m *SetScriptsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetScriptsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetScriptsResponse proto.InternalMessageInfo

type ExecutionStats struct {
	ExecutionTimeNs   int64 `protobuf:"varint,1,opt,name=execution_time_ns,json=executionTimeNs,proto3" json:"execution_time_ns,omitempty"`
	CompilationTimeNs int64 `protobuf:"varint,2,opt,name=compilation_time_ns,json=compilationTimeNs,proto3" json:"compilation_time_ns,omitempty"`
	BytesProcessed    int64 `protobuf:"varint,3,opt,name=bytes_processed,json=bytesProcessed,proto3" json:"bytes_processed,omitempty"`
	RecordsProcessed  int64 `protobuf:"varint,4,opt,name=records_processed,json=recordsProcessed,proto3" json:"records_processed,omitempty"`
}

func (m *ExecutionStats) Reset()      { *m = ExecutionStats{} }
func (*ExecutionStats) ProtoMessage() {}
func (*ExecutionStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{26}
}
func (m *ExecutionStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecutionStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecutionStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecutionStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecutionStats.Merge(m, src)
}
func (m *ExecutionStats) XXX_Size() int {
	return m.Size()
}
func (m *ExecutionStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecutionStats.DiscardUnknown(m)
}

var xxx_messageInfo_ExecutionStats proto.InternalMessageInfo

func (m *ExecutionStats) GetExecutionTimeNs() int64 {
	if m != nil {
		return m.ExecutionTimeNs
	}
	return 0
}

func (m *ExecutionStats) GetCompilationTimeNs() int64 {
	if m != nil {
		return m.CompilationTimeNs
	}
	return 0
}

func (m *ExecutionStats) GetBytesProcessed() int64 {
	if m != nil {
		return m.BytesProcessed
	}
	return 0
}

func (m *ExecutionStats) GetRecordsProcessed() int64 {
	if m != nil {
		return m.RecordsProcessed
	}
	return 0
}

type RecordExecutionResultRequest struct {
	ScriptID  *uuidpb.UUID     `protobuf:"bytes,1,opt,name=script_id,json=scriptId,proto3" json:"script_id,omitempty"`
	Timestamp *types.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Types that are valid to be assigned to Result:
	//	*RecordExecutionResultRequest_Error
	//	*RecordExecutionResultRequest_ExecutionStats
	Result isRecordExecutionResultRequest_Result `protobuf_oneof:"result"`
}

func (m *RecordExecutionResultRequest) Reset()      { *m = RecordExecutionResultRequest{} }
func (*RecordExecutionResultRequest) ProtoMessage() {}
func (*RecordExecutionResultRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{27}
}
func (m *RecordExecutionResultRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecordExecutionResultRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecordExecutionResultRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RecordExecutionResultRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecordExecutionResultRequest.Merge(m, src)
}
func (m *RecordExecutionResultRequest) XXX_Size() int {
	return m.Size()
}
func (m *RecordExecutionResultRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RecordExecutionResultRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RecordExecutionResultRequest proto.InternalMessageInfo

type isRecordExecutionResultRequest_Result interface {
	isRecordExecutionResultRequest_Result()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type RecordExecutionResultRequest_Error struct {
	Error *statuspb.Status `protobuf:"bytes,3,opt,name=error,proto3,oneof" json:"error,omitempty"`
}
type RecordExecutionResultRequest_ExecutionStats struct {
	ExecutionStats *ExecutionStats `protobuf:"bytes,4,opt,name=execution_stats,json=executionStats,proto3,oneof" json:"execution_stats,omitempty"`
}

func (*RecordExecutionResultRequest_Error) isRecordExecutionResultRequest_Result()          {}
func (*RecordExecutionResultRequest_ExecutionStats) isRecordExecutionResultRequest_Result() {}

func (m *RecordExecutionResultRequest) GetResult() isRecordExecutionResultRequest_Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *RecordExecutionResultRequest) GetScriptID() *uuidpb.UUID {
	if m != nil {
		return m.ScriptID
	}
	return nil
}

func (m *RecordExecutionResultRequest) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *RecordExecutionResultRequest) GetError() *statuspb.Status {
	if x, ok := m.GetResult().(*RecordExecutionResultRequest_Error); ok {
		return x.Error
	}
	return nil
}

func (m *RecordExecutionResultRequest) GetExecutionStats() *ExecutionStats {
	if x, ok := m.GetResult().(*RecordExecutionResultRequest_ExecutionStats); ok {
		return x.ExecutionStats
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RecordExecutionResultRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RecordExecutionResultRequest_Error)(nil),
		(*RecordExecutionResultRequest_ExecutionStats)(nil),
	}
}

type RecordExecutionResultResponse struct {
}

func (m *RecordExecutionResultResponse) Reset()      { *m = RecordExecutionResultResponse{} }
func (*RecordExecutionResultResponse) ProtoMessage() {}
func (*RecordExecutionResultResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{28}
}
func (m *RecordExecutionResultResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecordExecutionResultResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecordExecutionResultResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RecordExecutionResultResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecordExecutionResultResponse.Merge(m, src)
}
func (m *RecordExecutionResultResponse) XXX_Size() int {
	return m.Size()
}
func (m *RecordExecutionResultResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RecordExecutionResultResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RecordExecutionResultResponse proto.InternalMessageInfo

type GetAllExecutionResultsRequest struct {
}

func (m *GetAllExecutionResultsRequest) Reset()      { *m = GetAllExecutionResultsRequest{} }
func (*GetAllExecutionResultsRequest) ProtoMessage() {}
func (*GetAllExecutionResultsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{29}
}
func (m *GetAllExecutionResultsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAllExecutionResultsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAllExecutionResultsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetAllExecutionResultsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAllExecutionResultsRequest.Merge(m, src)
}
func (m *GetAllExecutionResultsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetAllExecutionResultsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAllExecutionResultsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetAllExecutionResultsRequest proto.InternalMessageInfo

type GetAllExecutionResultsResponse struct {
	Results []*GetAllExecutionResultsResponse_ExecutionResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
}

func (m *GetAllExecutionResultsResponse) Reset()      { *m = GetAllExecutionResultsResponse{} }
func (*GetAllExecutionResultsResponse) ProtoMessage() {}
func (*GetAllExecutionResultsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{30}
}
func (m *GetAllExecutionResultsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAllExecutionResultsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAllExecutionResultsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetAllExecutionResultsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAllExecutionResultsResponse.Merge(m, src)
}
func (m *GetAllExecutionResultsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetAllExecutionResultsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAllExecutionResultsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetAllExecutionResultsResponse proto.InternalMessageInfo

func (m *GetAllExecutionResultsResponse) GetResults() []*GetAllExecutionResultsResponse_ExecutionResult {
	if m != nil {
		return m.Results
	}
	return nil
}

type GetAllExecutionResultsResponse_ExecutionResult struct {
	ScriptID  *uuidpb.UUID     `protobuf:"bytes,1,opt,name=script_id,json=scriptId,proto3" json:"script_id,omitempty"`
	Timestamp *types.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Types that are valid to be assigned to Result:
	//	*GetAllExecutionResultsResponse_ExecutionResult_Error
	//	*GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats
	Result isGetAllExecutionResultsResponse_ExecutionResult_Result `protobuf_oneof:"result"`
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) Reset() {
	*m = GetAllExecutionResultsResponse_ExecutionResult{}
}
func (*GetAllExecutionResultsResponse_ExecutionResult) ProtoMessage() {}
func (*GetAllExecutionResultsResponse_ExecutionResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe4468195647430, []int{30, 0}
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAllExecutionResultsResponse_ExecutionResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAllExecutionResultsResponse_ExecutionResult.Merge(m, src)
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) XXX_Size() int {
	return m.Size()
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAllExecutionResultsResponse_ExecutionResult.DiscardUnknown(m)
}

var xxx_messageInfo_GetAllExecutionResultsResponse_ExecutionResult proto.InternalMessageInfo

type isGetAllExecutionResultsResponse_ExecutionResult_Result interface {
	isGetAllExecutionResultsResponse_ExecutionResult_Result()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type GetAllExecutionResultsResponse_ExecutionResult_Error struct {
	Error *statuspb.Status `protobuf:"bytes,3,opt,name=error,proto3,oneof" json:"error,omitempty"`
}
type GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats struct {
	ExecutionStats *ExecutionStats `protobuf:"bytes,4,opt,name=execution_stats,json=executionStats,proto3,oneof" json:"execution_stats,omitempty"`
}

func (*GetAllExecutionResultsResponse_ExecutionResult_Error) isGetAllExecutionResultsResponse_ExecutionResult_Result() {
}
func (*GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) isGetAllExecutionResultsResponse_ExecutionResult_Result() {
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) GetResult() isGetAllExecutionResultsResponse_ExecutionResult_Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) GetScriptID() *uuidpb.UUID {
	if m != nil {
		return m.ScriptID
	}
	return nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) GetError() *statuspb.Status {
	if x, ok := m.GetResult().(*GetAllExecutionResultsResponse_ExecutionResult_Error); ok {
		return x.Error
	}
	return nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) GetExecutionStats() *ExecutionStats {
	if x, ok := m.GetResult().(*GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats); ok {
		return x.ExecutionStats
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GetAllExecutionResultsResponse_ExecutionResult) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GetAllExecutionResultsResponse_ExecutionResult_Error)(nil),
		(*GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats)(nil),
	}
}

func init() {
	proto.RegisterType((*SchemaRequest)(nil), "px.vizier.services.metadata.SchemaRequest")
	proto.RegisterType((*SchemaResponse)(nil), "px.vizier.services.metadata.SchemaResponse")
	proto.RegisterType((*AgentInfoRequest)(nil), "px.vizier.services.metadata.AgentInfoRequest")
	proto.RegisterType((*AgentInfoResponse)(nil), "px.vizier.services.metadata.AgentInfoResponse")
	proto.RegisterType((*AgentMetadata)(nil), "px.vizier.services.metadata.AgentMetadata")
	proto.RegisterType((*AgentUpdatesRequest)(nil), "px.vizier.services.metadata.AgentUpdatesRequest")
	proto.RegisterType((*AgentUpdate)(nil), "px.vizier.services.metadata.AgentUpdate")
	proto.RegisterType((*AgentUpdatesResponse)(nil), "px.vizier.services.metadata.AgentUpdatesResponse")
	proto.RegisterType((*WithPrefixKeyRequest)(nil), "px.vizier.services.metadata.WithPrefixKeyRequest")
	proto.RegisterType((*WithPrefixKeyResponse)(nil), "px.vizier.services.metadata.WithPrefixKeyResponse")
	proto.RegisterType((*WithPrefixKeyResponse_KV)(nil), "px.vizier.services.metadata.WithPrefixKeyResponse.KV")
	proto.RegisterType((*RegisterTracepointRequest)(nil), "px.vizier.services.metadata.RegisterTracepointRequest")
	proto.RegisterType((*RegisterTracepointRequest_TracepointRequest)(nil), "px.vizier.services.metadata.RegisterTracepointRequest.TracepointRequest")
	proto.RegisterType((*RegisterTracepointResponse)(nil), "px.vizier.services.metadata.RegisterTracepointResponse")
	proto.RegisterType((*RegisterTracepointResponse_TracepointStatus)(nil), "px.vizier.services.metadata.RegisterTracepointResponse.TracepointStatus")
	proto.RegisterType((*GetTracepointInfoRequest)(nil), "px.vizier.services.metadata.GetTracepointInfoRequest")
	proto.RegisterType((*GetTracepointInfoResponse)(nil), "px.vizier.services.metadata.GetTracepointInfoResponse")
	proto.RegisterType((*GetTracepointInfoResponse_TracepointState)(nil), "px.vizier.services.metadata.GetTracepointInfoResponse.TracepointState")
	proto.RegisterType((*RemoveTracepointRequest)(nil), "px.vizier.services.metadata.RemoveTracepointRequest")
	proto.RegisterType((*RemoveTracepointResponse)(nil), "px.vizier.services.metadata.RemoveTracepointResponse")
	proto.RegisterType((*UpdateConfigRequest)(nil), "px.vizier.services.metadata.UpdateConfigRequest")
	proto.RegisterType((*UpdateConfigResponse)(nil), "px.vizier.services.metadata.UpdateConfigResponse")
	proto.RegisterType((*GetScriptsRequest)(nil), "px.vizier.services.metadata.GetScriptsRequest")
	proto.RegisterType((*GetScriptsResponse)(nil), "px.vizier.services.metadata.GetScriptsResponse")
	proto.RegisterMapType((map[string]*cvmsgspb.CronScript)(nil), "px.vizier.services.metadata.GetScriptsResponse.ScriptsEntry")
	proto.RegisterType((*AddOrUpdateScriptRequest)(nil), "px.vizier.services.metadata.AddOrUpdateScriptRequest")
	proto.RegisterType((*AddOrUpdateScriptResponse)(nil), "px.vizier.services.metadata.AddOrUpdateScriptResponse")
	proto.RegisterType((*DeleteScriptRequest)(nil), "px.vizier.services.metadata.DeleteScriptRequest")
	proto.RegisterType((*DeleteScriptResponse)(nil), "px.vizier.services.metadata.DeleteScriptResponse")
	proto.RegisterType((*SetScriptsRequest)(nil), "px.vizier.services.metadata.SetScriptsRequest")
	proto.RegisterMapType((map[string]*cvmsgspb.CronScript)(nil), "px.vizier.services.metadata.SetScriptsRequest.ScriptsEntry")
	proto.RegisterType((*SetScriptsResponse)(nil), "px.vizier.services.metadata.SetScriptsResponse")
	proto.RegisterType((*ExecutionStats)(nil), "px.vizier.services.metadata.ExecutionStats")
	proto.RegisterType((*RecordExecutionResultRequest)(nil), "px.vizier.services.metadata.RecordExecutionResultRequest")
	proto.RegisterType((*RecordExecutionResultResponse)(nil), "px.vizier.services.metadata.RecordExecutionResultResponse")
	proto.RegisterType((*GetAllExecutionResultsRequest)(nil), "px.vizier.services.metadata.GetAllExecutionResultsRequest")
	proto.RegisterType((*GetAllExecutionResultsResponse)(nil), "px.vizier.services.metadata.GetAllExecutionResultsResponse")
	proto.RegisterType((*GetAllExecutionResultsResponse_ExecutionResult)(nil), "px.vizier.services.metadata.GetAllExecutionResultsResponse.ExecutionResult")
}

func init() {
	proto.RegisterFile("src/vizier/services/metadata/metadatapb/service.proto", fileDescriptor_bfe4468195647430)
}

var fileDescriptor_bfe4468195647430 = []byte{
	// 2028 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xdd, 0x6f, 0x23, 0x57,
	0x15, 0xf7, 0x78, 0xf2, 0xe1, 0x9c, 0x64, 0xf3, 0x71, 0x93, 0x6c, 0x13, 0x2f, 0x75, 0xb6, 0x23,
	0xa0, 0xab, 0x4d, 0x77, 0xa6, 0x6b, 0xba, 0x4d, 0xd9, 0x96, 0xaa, 0x9b, 0xb8, 0x4d, 0xac, 0x6c,
	0xdb, 0x30, 0xce, 0x06, 0x89, 0x17, 0x6b, 0x3c, 0x73, 0xe3, 0x0c, 0xf5, 0x7c, 0x30, 0x73, 0x1d,
	0x12, 0x84, 0x04, 0x42, 0xe2, 0x0d, 0x55, 0xf4, 0x01, 0xa4, 0xbe, 0x81, 0x78, 0x81, 0x67, 0xfe,
	0x00, 0x04, 0x4f, 0x3c, 0xee, 0x13, 0xaa, 0x10, 0x5a, 0xb1, 0xde, 0x17, 0x9e, 0x50, 0xff, 0x04,
	0x74, 0xbf, 0xec, 0x19, 0x7b, 0x6c, 0xc7, 0x01, 0xf1, 0xc4, 0x53, 0xee, 0x9c, 0x39, 0xe7, 0x77,
	0xcf, 0xfd, 0x9d, 0x73, 0xef, 0xfd, 0x8d, 0x03, 0x0f, 0xe2, 0xc8, 0x36, 0xce, 0xdd, 0x1f, 0xba,
	0x38, 0x32, 0x62, 0x1c, 0x9d, 0xbb, 0x36, 0x8e, 0x0d, 0x0f, 0x13, 0xcb, 0xb1, 0x88, 0xd5, 0x1d,
	0x84, 0x0d, 0xf9, 0x52, 0x0f, 0xa3, 0x80, 0x04, 0xe8, 0x56, 0x78, 0xa1, 0xf3, 0x28, 0x5d, 0x46,
	0xe9, 0xd2, 0xb9, 0x78, 0xaf, 0xe9, 0x92, 0xb3, 0x76, 0x43, 0xb7, 0x03, 0xcf, 0x68, 0x06, 0xcd,
	0xc0, 0x60, 0x31, 0x8d, 0xf6, 0x29, 0x7b, 0x62, 0x0f, 0x6c, 0xc4, 0xb1, 0x8a, 0xa5, 0x66, 0x10,
	0x34, 0x5b, 0xb8, 0xe7, 0xe5, 0xb4, 0x23, 0x8b, 0xb8, 0x81, 0x2f, 0xde, 0x6f, 0xf5, 0xbf, 0x27,
	0xae, 0x87, 0x63, 0x62, 0x79, 0xa1, 0x74, 0xa0, 0x6b, 0xb0, 0x42, 0x97, 0x7b, 0x18, 0xed, 0xb6,
	0xeb, 0x84, 0x0d, 0xf6, 0x47, 0x38, 0xec, 0x50, 0x07, 0xdb, 0x8a, 0xfc, 0x80, 0x18, 0x61, 0xcb,
	0xf2, 0x7d, 0x1c, 0x19, 0x8e, 0x1b, 0x93, 0xc8, 0x6d, 0xb4, 0x09, 0xa6, 0xce, 0x89, 0xa7, 0x3a,
	0xf5, 0x10, 0x81, 0xdf, 0xca, 0x0a, 0xbc, 0xf4, 0x2d, 0xcf, 0xb5, 0xeb, 0x24, 0xb2, 0x6c, 0xd7,
	0x6f, 0x1a, 0x6e, 0x64, 0xb4, 0x82, 0xa6, 0x6b, 0x5b, 0xad, 0xb0, 0x21, 0x47, 0x22, 0xfc, 0x6b,
	0x2c, 0x3c, 0xf0, 0xbc, 0xc0, 0x37, 0x1a, 0x56, 0x8c, 0x8d, 0x98, 0x58, 0xa4, 0x1d, 0x53, 0x36,
	0xd9, 0x20, 0xe9, 0x46, 0xac, 0x46, 0x0b, 0xd7, 0x63, 0x12, 0x44, 0xd8, 0x88, 0xed, 0x33, 0xec,
	0x31, 0xd2, 0xd9, 0x40, 0xb8, 0xdd, 0x4b, 0x94, 0xca, 0xc3, 0x71, 0x6c, 0x35, 0x59, 0xa9, 0xf8,
	0x20, 0x6c, 0x74, 0x87, 0xc2, 0x5d, 0xcf, 0xaa, 0x6c, 0x7c, 0x66, 0x45, 0xd8, 0x31, 0xac, 0x26,
	0xf6, 0x49, 0xd8, 0xe0, 0x7f, 0x85, 0xff, 0x6d, 0xea, 0x2f, 0xde, 0xdb, 0xe7, 0x5e, 0xdc, 0xa4,
	0x98, 0x7c, 0xc0, 0x3d, 0xb4, 0x25, 0xb8, 0x51, 0x63, 0x09, 0x99, 0xf8, 0xfb, 0x6d, 0x1c, 0x13,
	0xad, 0x0a, 0x8b, 0xd2, 0x10, 0x87, 0x81, 0x1f, 0x63, 0xb4, 0x03, 0x33, 0x3c, 0xe7, 0x8d, 0xfc,
	0x6d, 0xe5, 0xce, 0x7c, 0x79, 0x4b, 0x0f, 0x2f, 0xf4, 0xc4, 0xd2, 0x74, 0xb9, 0x34, 0x5d, 0x04,
	0x0a, 0x77, 0x0d, 0xc1, 0xf2, 0x23, 0x9a, 0x4c, 0xd5, 0x3f, 0x0d, 0x24, 0x7c, 0x0d, 0x56, 0x12,
	0x36, 0x31, 0xc3, 0xbb, 0x30, 0xe5, 0xfa, 0xa7, 0xc1, 0x86, 0x72, 0x5b, 0xbd, 0x33, 0x5f, 0xbe,
	0xab, 0x8f, 0x68, 0x44, 0x9d, 0x45, 0x7f, 0x28, 0x9e, 0x4c, 0x16, 0xa7, 0x3d, 0x57, 0xe0, 0x46,
	0xca, 0x8e, 0xde, 0x81, 0x69, 0xc6, 0xc3, 0x86, 0xc2, 0x52, 0xfe, 0x7a, 0x16, 0x24, 0xe7, 0x45,
	0xe7, 0x7c, 0xb1, 0x70, 0x93, 0x07, 0xa1, 0x0a, 0xcc, 0xf0, 0x62, 0x8a, 0x15, 0xbf, 0x76, 0xb5,
	0xf0, 0x1a, 0x8b, 0x31, 0x45, 0x2c, 0x7a, 0x0c, 0xf3, 0xbc, 0xcd, 0xea, 0x6c, 0x71, 0x2a, 0x83,
	0xda, 0xa6, 0x50, 0xdc, 0xac, 0x8b, 0xee, 0xd3, 0x53, 0x6d, 0xab, 0xef, 0xb1, 0x97, 0x8c, 0x1f,
	0xb0, 0xbb, 0x63, 0xed, 0x73, 0x05, 0x56, 0xd9, 0x2c, 0x4f, 0x42, 0xc7, 0x22, 0x38, 0x16, 0x84,
	0xa2, 0x2a, 0xac, 0x7a, 0xd6, 0x45, 0xbd, 0xcd, 0xac, 0x75, 0xd7, 0x27, 0x38, 0x3a, 0xb7, 0x5a,
	0x62, 0xdd, 0x9b, 0x3a, 0xdf, 0x67, 0xba, 0xdc, 0x67, 0x7a, 0x45, 0xec, 0x43, 0x73, 0xc5, 0xb3,
	0x2e, 0x38, 0x54, 0x55, 0xc4, 0xa0, 0x1d, 0xd8, 0xe8, 0x41, 0xc5, 0xf5, 0x10, 0x47, 0xf5, 0x48,
	0x94, 0x88, 0x11, 0x31, 0x6d, 0xae, 0x77, 0x83, 0xe2, 0x23, 0x1c, 0xc9, 0xfa, 0x69, 0xff, 0x52,
	0x60, 0x3e, 0x91, 0x1b, 0xda, 0x81, 0x02, 0xa3, 0xa5, 0xee, 0x3a, 0x22, 0x91, 0x25, 0xba, 0x6c,
	0xbe, 0x89, 0xf5, 0x27, 0x4f, 0xaa, 0x95, 0xdd, 0xf9, 0xce, 0xb3, 0xad, 0x59, 0xde, 0x09, 0x15,
	0x73, 0x96, 0x79, 0x57, 0x1d, 0x54, 0x84, 0x59, 0x07, 0xb7, 0x30, 0xc1, 0x0e, 0x9b, 0xb0, 0x70,
	0x90, 0x33, 0xa5, 0x01, 0xbd, 0x2b, 0x4b, 0xaa, 0x4e, 0x52, 0xd2, 0x83, 0x9c, 0x2c, 0xea, 0x7b,
	0x30, 0x47, 0x5b, 0x83, 0x17, 0x63, 0x8a, 0x61, 0xbc, 0x92, 0xc0, 0xe8, 0xee, 0x34, 0x16, 0x56,
	0xb1, 0x88, 0x45, 0x69, 0x3f, 0xc8, 0x99, 0x05, 0x47, 0x8c, 0x77, 0x0b, 0x30, 0xc3, 0xb9, 0xd1,
	0x3e, 0xcb, 0xc3, 0x5a, 0xba, 0x18, 0xa2, 0x93, 0x3f, 0x84, 0x1b, 0x7c, 0xe5, 0x82, 0x44, 0xd1,
	0xd2, 0x77, 0xc6, 0xb7, 0x34, 0x47, 0x32, 0x17, 0xac, 0x04, 0x2c, 0x3a, 0x92, 0x70, 0x7c, 0x47,
	0xd1, 0x7e, 0x54, 0xaf, 0xd4, 0x44, 0x7c, 0x27, 0xb2, 0x26, 0xe2, 0x88, 0xdc, 0x10, 0xa3, 0x32,
	0xac, 0xa7, 0x10, 0x45, 0xa2, 0x0e, 0x63, 0xb5, 0x60, 0xae, 0x26, 0x9d, 0x79, 0x16, 0x0e, 0xfa,
	0x2a, 0x2c, 0x62, 0xdf, 0xa9, 0x07, 0xa7, 0xf5, 0x73, 0x1c, 0xc5, 0x6e, 0xe0, 0x33, 0xfa, 0x0a,
	0xe6, 0x02, 0xf6, 0x9d, 0x8f, 0x4f, 0x4f, 0xb8, 0x4d, 0xab, 0xc0, 0xda, 0x77, 0x5c, 0x72, 0x76,
	0x14, 0xe1, 0x53, 0xf7, 0xe2, 0x10, 0x5f, 0xca, 0x06, 0xbd, 0x09, 0x33, 0x21, 0xb3, 0xb1, 0x56,
	0x98, 0x33, 0xc5, 0x13, 0x5a, 0x83, 0x69, 0xd6, 0x95, 0xac, 0xd2, 0x73, 0x26, 0x7f, 0xd0, 0x3e,
	0x55, 0x60, 0xbd, 0x0f, 0x46, 0x50, 0xbb, 0x0f, 0xea, 0x27, 0xe7, 0x92, 0xd0, 0x07, 0x23, 0x09,
	0xcd, 0x04, 0xd0, 0x0f, 0x4f, 0x4c, 0x8a, 0x50, 0x7c, 0x0d, 0xf2, 0x87, 0x27, 0x68, 0x19, 0xd4,
	0x4f, 0xf0, 0xa5, 0xc8, 0x89, 0x0e, 0x69, 0x42, 0xe7, 0x56, 0xab, 0xcd, 0x7b, 0x7d, 0xc1, 0xe4,
	0x0f, 0xda, 0xdf, 0xf2, 0xb0, 0x69, 0xe2, 0xa6, 0x1b, 0x13, 0x1c, 0x1d, 0x47, 0x96, 0x8d, 0xc3,
	0xc0, 0xf5, 0x89, 0x5c, 0x9c, 0x03, 0x85, 0x88, 0x0f, 0x65, 0x66, 0x07, 0x23, 0x33, 0x1b, 0x8a,
	0xa4, 0x0f, 0x58, 0xcc, 0x2e, 0x72, 0xf1, 0xaf, 0x0a, 0xac, 0x0c, 0xce, 0xfd, 0x03, 0x58, 0x27,
	0x5d, 0x63, 0xdd, 0xc1, 0x61, 0x2b, 0xb8, 0xf4, 0x7a, 0x67, 0xde, 0x6e, 0x56, 0x93, 0xa4, 0xef,
	0x39, 0xdd, 0x8d, 0x74, 0x79, 0xbb, 0xf5, 0xf0, 0x2b, 0x5d, 0x24, 0x73, 0x8d, 0x64, 0x58, 0x11,
	0x82, 0x29, 0xdf, 0xf2, 0xb0, 0x28, 0x1c, 0x1b, 0xa3, 0x37, 0x40, 0x25, 0xa4, 0x25, 0xf6, 0xe6,
	0xf0, 0x63, 0x67, 0x77, 0xb6, 0xf3, 0x6c, 0x4b, 0x3d, 0x3e, 0x7e, 0x6c, 0x52, 0x77, 0xed, 0x0f,
	0x79, 0x28, 0x66, 0x51, 0x22, 0x4a, 0xfe, 0x3d, 0x98, 0xef, 0x25, 0x70, 0x7d, 0x82, 0x45, 0xfd,
	0x7b, 0x26, 0x71, 0x50, 0x27, 0xc1, 0xd1, 0x76, 0xdf, 0x99, 0xbf, 0x4a, 0xa7, 0x91, 0x77, 0xbb,
	0x9e, 0x3e, 0xda, 0x8b, 0x3f, 0x82, 0xe5, 0x7e, 0xb4, 0x04, 0x80, 0x32, 0x16, 0x00, 0xbd, 0x0a,
	0x79, 0xd7, 0x11, 0x33, 0x0d, 0x9c, 0x8d, 0x33, 0x9d, 0x67, 0x5b, 0xf9, 0x6a, 0xc5, 0xcc, 0xbb,
	0x4e, 0x97, 0x6b, 0xb5, 0xc7, 0xb5, 0xf6, 0x01, 0x6c, 0xec, 0x63, 0xd2, 0x4b, 0x20, 0x71, 0xbf,
	0xa2, 0xbb, 0xa0, 0xba, 0x8e, 0xa4, 0x6a, 0x00, 0x99, 0xb1, 0x5f, 0xad, 0xc4, 0x26, 0x75, 0xd2,
	0x7e, 0xa3, 0xc2, 0x66, 0x06, 0x90, 0x20, 0xff, 0x2c, 0x8b, 0xfc, 0x0f, 0x46, 0x92, 0x3f, 0x14,
	0xac, 0x8f, 0x7b, 0x9c, 0xa2, 0xbe, 0xf8, 0x79, 0x1e, 0x96, 0xfa, 0x1c, 0x04, 0x41, 0xca, 0x78,
	0x82, 0xee, 0xc3, 0x34, 0xe5, 0x94, 0x77, 0xe3, 0x62, 0xf9, 0x56, 0x8a, 0xf5, 0xc7, 0xee, 0x29,
	0xde, 0xbb, 0xb4, 0x5b, 0x98, 0xcf, 0xca, 0x3d, 0x91, 0x01, 0x05, 0xee, 0x81, 0xe3, 0x0d, 0x95,
	0x2d, 0x2b, 0xb3, 0x56, 0x5d, 0xa7, 0x6e, 0x11, 0xa6, 0x12, 0x0d, 0xbf, 0x0b, 0x8b, 0xf8, 0x22,
	0xc4, 0x36, 0x55, 0x97, 0x3c, 0x81, 0xe9, 0xf1, 0x09, 0xdc, 0x90, 0x21, 0x7c, 0x91, 0xaf, 0xc0,
	0x02, 0x3f, 0x86, 0xeb, 0x14, 0x32, 0xde, 0x98, 0xb9, 0xad, 0xde, 0x99, 0x33, 0xe7, 0xb9, 0xed,
	0x23, 0x6a, 0xd2, 0x0c, 0x78, 0xc9, 0xc4, 0x5e, 0x70, 0x8e, 0x07, 0xf7, 0xff, 0x1a, 0x4c, 0xf3,
	0x30, 0x85, 0x85, 0xf1, 0x07, 0x6d, 0x1f, 0x36, 0x06, 0x03, 0x44, 0x49, 0x27, 0x69, 0x51, 0xcd,
	0x86, 0x55, 0x7e, 0x01, 0xec, 0x05, 0xfe, 0xa9, 0xdb, 0x94, 0xb3, 0x8e, 0x39, 0x37, 0xe7, 0xc4,
	0xb9, 0x49, 0x2f, 0x0d, 0x7e, 0xd1, 0x84, 0x81, 0x53, 0x4f, 0xb4, 0x30, 0xbf, 0x8e, 0x8e, 0x02,
	0x87, 0xae, 0x4f, 0xdb, 0x83, 0xb5, 0xf4, 0x24, 0xd7, 0xc9, 0x74, 0x15, 0x56, 0xf6, 0x31, 0xa9,
	0xd9, 0x91, 0x1b, 0x12, 0xa9, 0x8b, 0xb4, 0x3f, 0x29, 0x80, 0x92, 0x56, 0x01, 0x7c, 0x02, 0xb3,
	0x31, 0x37, 0x89, 0x8e, 0x7e, 0x67, 0x5c, 0x47, 0xf7, 0x21, 0xe8, 0xe2, 0xf9, 0x7d, 0x9f, 0x44,
	0x97, 0xa6, 0x04, 0x2b, 0xd6, 0x60, 0x21, 0xf9, 0x22, 0x83, 0xa6, 0x7b, 0x49, 0x9a, 0xe6, 0xcb,
	0x2f, 0xb1, 0xe3, 0x59, 0x68, 0x72, 0x7d, 0x2f, 0x0a, 0x7c, 0x1e, 0x2f, 0xf8, 0x7b, 0x98, 0x7f,
	0x4b, 0xd1, 0x0e, 0x61, 0xe3, 0x91, 0xe3, 0x7c, 0x1c, 0x71, 0x8a, 0xc4, 0x7b, 0x51, 0x07, 0x83,
	0xaa, 0x72, 0x6a, 0x10, 0x0c, 0x0d, 0xc5, 0x13, 0x6e, 0xda, 0x2d, 0xd8, 0xcc, 0x00, 0x13, 0x0a,
	0xee, 0xdb, 0xb0, 0x5a, 0x61, 0x3a, 0x2b, 0x3d, 0xc9, 0x43, 0x98, 0xe3, 0xd1, 0x23, 0x94, 0xdc,
	0x42, 0xe7, 0xd9, 0x56, 0x81, 0x87, 0x55, 0x2b, 0x66, 0x81, 0xfb, 0x57, 0x1d, 0xed, 0x26, 0xac,
	0xa5, 0x21, 0xc5, 0x54, 0x7f, 0x54, 0x60, 0xa5, 0xd6, 0x5f, 0x2e, 0xf4, 0xa4, 0xbf, 0x2e, 0x6f,
	0x8f, 0xac, 0xcb, 0x00, 0xc0, 0xff, 0xb2, 0x2c, 0x6b, 0x80, 0x6a, 0x03, 0x7d, 0xa1, 0xfd, 0x59,
	0x81, 0xc5, 0xf7, 0x2f, 0xb0, 0xdd, 0xa6, 0xf7, 0x1c, 0xed, 0xd0, 0x18, 0xdd, 0x85, 0x15, 0x2c,
	0x2d, 0x75, 0xfa, 0x85, 0x5b, 0xf7, 0x79, 0x43, 0xab, 0xe6, 0x52, 0xf7, 0xc5, 0xb1, 0xeb, 0xe1,
	0x8f, 0x62, 0xa4, 0xc3, 0xaa, 0x1d, 0x78, 0xa1, 0xdb, 0xb2, 0x52, 0xde, 0x79, 0xe6, 0xbd, 0x92,
	0x78, 0x25, 0xfc, 0x5f, 0x85, 0xa5, 0xc6, 0x25, 0x93, 0xe9, 0x51, 0x60, 0xe3, 0x38, 0x16, 0x12,
	0x4e, 0x35, 0x17, 0x99, 0xf9, 0x48, 0x5a, 0xd1, 0x36, 0xac, 0x44, 0xd8, 0x0e, 0x22, 0x27, 0xe9,
	0x3a, 0xc5, 0x5c, 0x97, 0xc5, 0x8b, 0xae, 0xb3, 0xf6, 0xdb, 0x3c, 0x7c, 0xc5, 0x64, 0xc6, 0xee,
	0x52, 0x4c, 0x1c, 0xb7, 0x5b, 0xff, 0x8d, 0x8e, 0x40, 0x6f, 0xc1, 0x5c, 0xf7, 0x33, 0x5f, 0xd0,
	0x5d, 0x1c, 0x50, 0x0a, 0xc7, 0xd2, 0xc3, 0xec, 0x39, 0xa3, 0x6d, 0x98, 0xc6, 0x51, 0x14, 0x44,
	0x42, 0x5f, 0x64, 0x9d, 0x06, 0x54, 0xe8, 0x33, 0x1f, 0x74, 0x02, 0x3d, 0x72, 0xd9, 0xd1, 0x1c,
	0x0b, 0xb9, 0xbf, 0x3d, 0xb2, 0xa5, 0xd2, 0xb5, 0x3b, 0xc8, 0x99, 0x8b, 0x38, 0x65, 0xa1, 0xf2,
	0x3f, 0x62, 0x5c, 0x68, 0x5b, 0xf0, 0xf2, 0x10, 0x92, 0x44, 0x2f, 0x6c, 0xc1, 0xcb, 0xfb, 0x98,
	0x3c, 0x6a, 0xb5, 0xfa, 0x1c, 0xba, 0xa7, 0xd3, 0xaf, 0x55, 0x28, 0x0d, 0xf3, 0x10, 0x27, 0x15,
	0x86, 0x59, 0x3e, 0x9d, 0xdc, 0x11, 0x87, 0xe3, 0x4e, 0xaa, 0x11, 0x68, 0x7a, 0x7f, 0xa6, 0x12,
	0xbb, 0xf8, 0xab, 0x3c, 0x2c, 0xf5, 0xbd, 0xfc, 0x7f, 0x91, 0xdb, 0x2d, 0x52, 0xfe, 0xbb, 0x0a,
	0x4b, 0xf2, 0xf7, 0x84, 0x1a, 0x07, 0x42, 0x17, 0xb0, 0x44, 0x79, 0x4e, 0x7e, 0xa2, 0xbd, 0x7e,
	0xd5, 0x4f, 0x3b, 0x59, 0xfb, 0xe2, 0xfd, 0x09, 0x22, 0x78, 0xf5, 0x5e, 0x57, 0x10, 0x06, 0x60,
	0x77, 0x11, 0xff, 0x8a, 0x1b, 0xfd, 0x13, 0x49, 0xea, 0x07, 0x9d, 0xe2, 0xf6, 0x95, 0x7c, 0x45,
	0xd3, 0x79, 0xb0, 0x20, 0x17, 0x48, 0xf5, 0x1b, 0xba, 0x37, 0x3e, 0xd7, 0x84, 0xfa, 0x2c, 0xea,
	0x57, 0x75, 0x17, 0xd3, 0x5d, 0xc2, 0xf2, 0x3e, 0x26, 0xa9, 0xcf, 0x35, 0x74, 0x7f, 0x92, 0x4f,
	0x3b, 0x3e, 0x6d, 0x79, 0xf2, 0xaf, 0xc1, 0xf2, 0xef, 0x55, 0xd8, 0x94, 0xe5, 0x4d, 0x88, 0x4f,
	0x51, 0xe8, 0x9f, 0x29, 0x80, 0x06, 0x3f, 0x25, 0xd0, 0x9b, 0xd7, 0xfb, 0xb8, 0x2b, 0xee, 0x5c,
	0xf3, 0x9b, 0x05, 0xfd, 0x54, 0x61, 0xda, 0x26, 0xad, 0xaa, 0xd1, 0x83, 0x49, 0x55, 0x38, 0xcf,
	0xe2, 0xcd, 0xeb, 0x89, 0x77, 0xf4, 0x63, 0x58, 0xee, 0x97, 0x94, 0xe8, 0x8d, 0x31, 0x2b, 0xca,
	0x94, 0xac, 0xc5, 0x07, 0x13, 0x46, 0x89, 0x5a, 0xfd, 0x5c, 0x81, 0x75, 0x59, 0x2b, 0x2e, 0x14,
	0x65, 0x9d, 0x62, 0x58, 0x48, 0xea, 0xc7, 0x31, 0xbb, 0x31, 0x43, 0xcf, 0x8e, 0xd9, 0x8d, 0x59,
	0xe2, 0xb4, 0xfc, 0xcb, 0x19, 0xb8, 0xd9, 0x53, 0x06, 0x35, 0x12, 0x44, 0x58, 0xe6, 0xe3, 0x89,
	0x6d, 0xca, 0xa4, 0x01, 0xd2, 0xaf, 0xac, 0x2d, 0x79, 0x2e, 0xc6, 0x84, 0x5a, 0x94, 0xb5, 0xc7,
	0x80, 0xa8, 0x1b, 0xd3, 0x1e, 0xc3, 0x14, 0xe5, 0x98, 0xf6, 0x18, 0xaa, 0x1d, 0x69, 0x0d, 0x92,
	0x42, 0x6f, 0x4c, 0x0d, 0x32, 0x64, 0xe6, 0x98, 0x1a, 0x64, 0xa9, 0x48, 0x4a, 0x74, 0xed, 0xaa,
	0x44, 0xd7, 0x26, 0x24, 0x7a, 0x50, 0xdc, 0xa1, 0x4f, 0x15, 0x58, 0xcf, 0xbc, 0xf2, 0xd1, 0x37,
	0xc7, 0xb4, 0xf4, 0x70, 0x2d, 0x55, 0x7c, 0x78, 0x9d, 0x50, 0x91, 0xd0, 0x67, 0x0a, 0xdc, 0xcc,
	0xbe, 0xf2, 0xd1, 0xc3, 0x6b, 0xe9, 0x04, 0x9e, 0xd2, 0xdb, 0xff, 0x81, 0xc6, 0xd8, 0x7d, 0xef,
	0xe9, 0xf3, 0x52, 0xee, 0x8b, 0xe7, 0xa5, 0xdc, 0x97, 0xcf, 0x4b, 0xca, 0x4f, 0x3a, 0x25, 0xe5,
	0x77, 0x9d, 0x92, 0xf2, 0x97, 0x4e, 0x49, 0x79, 0xda, 0x29, 0x29, 0xff, 0xe8, 0x94, 0x94, 0x7f,
	0x76, 0x4a, 0xb9, 0x2f, 0x3b, 0x25, 0xe5, 0x17, 0x2f, 0x4a, 0xb9, 0xa7, 0x2f, 0x4a, 0xb9, 0x2f,
	0x5e, 0x94, 0x72, 0xdf, 0x85, 0xde, 0x3f, 0xa4, 0x1a, 0x33, 0x4c, 0x21, 0x7c, 0xe3, 0xdf, 0x01,
	0x00, 0x00, 0xff, 0xff, 0xfc, 0x9b, 0xbc, 0xee, 0xc2, 0x1a, 0x00, 0x00,
}

func (this *SchemaRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SchemaRequest)
	if !ok {
		that2, ok := that.(SchemaRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *SchemaResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SchemaResponse)
	if !ok {
		that2, ok := that.(SchemaResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Schema.Equal(that1.Schema) {
		return false
	}
	return true
}
func (this *AgentInfoRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentInfoRequest)
	if !ok {
		that2, ok := that.(AgentInfoRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *AgentInfoResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentInfoResponse)
	if !ok {
		that2, ok := that.(AgentInfoResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Info) != len(that1.Info) {
		return false
	}
	for i := range this.Info {
		if !this.Info[i].Equal(that1.Info[i]) {
			return false
		}
	}
	return true
}
func (this *AgentMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentMetadata)
	if !ok {
		that2, ok := that.(AgentMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Agent.Equal(that1.Agent) {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if !this.CarnotInfo.Equal(that1.CarnotInfo) {
		return false
	}
	return true
}
func (this *AgentUpdatesRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdatesRequest)
	if !ok {
		that2, ok := that.(AgentUpdatesRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MaxUpdateInterval.Equal(that1.MaxUpdateInterval) {
		return false
	}
	if this.MaxUpdatesPerResponse != that1.MaxUpdatesPerResponse {
		return false
	}
	return true
}
func (this *AgentUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdate)
	if !ok {
		that2, ok := that.(AgentUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.AgentID.Equal(that1.AgentID) {
		return false
	}
	if that1.Update == nil {
		if this.Update != nil {
			return false
		}
	} else if this.Update == nil {
		return false
	} else if !this.Update.Equal(that1.Update) {
		return false
	}
	return true
}
func (this *AgentUpdate_Deleted) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdate_Deleted)
	if !ok {
		that2, ok := that.(AgentUpdate_Deleted)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Deleted != that1.Deleted {
		return false
	}
	return true
}
func (this *AgentUpdate_Agent) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdate_Agent)
	if !ok {
		that2, ok := that.(AgentUpdate_Agent)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Agent.Equal(that1.Agent) {
		return false
	}
	return true
}
func (this *AgentUpdate_DataInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdate_DataInfo)
	if !ok {
		that2, ok := that.(AgentUpdate_DataInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DataInfo.Equal(that1.DataInfo) {
		return false
	}
	return true
}
func (this *AgentUpdatesResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdatesResponse)
	if !ok {
		that2, ok := that.(AgentUpdatesResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.AgentUpdates) != len(that1.AgentUpdates) {
		return false
	}
	for i := range this.AgentUpdates {
		if !this.AgentUpdates[i].Equal(that1.AgentUpdates[i]) {
			return false
		}
	}
	if len(this.AgentSchemas) != len(that1.AgentSchemas) {
		return false
	}
	for i := range this.AgentSchemas {
		if !this.AgentSchemas[i].Equal(that1.AgentSchemas[i]) {
			return false
		}
	}
	if this.AgentSchemasUpdated != that1.AgentSchemasUpdated {
		return false
	}
	if this.EndOfVersion != that1.EndOfVersion {
		return false
	}
	return true
}
func (this *WithPrefixKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*WithPrefixKeyRequest)
	if !ok {
		that2, ok := that.(WithPrefixKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Prefix != that1.Prefix {
		return false
	}
	if this.Proto != that1.Proto {
		return false
	}
	return true
}
func (this *WithPrefixKeyResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*WithPrefixKeyResponse)
	if !ok {
		that2, ok := that.(WithPrefixKeyResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Kvs) != len(that1.Kvs) {
		return false
	}
	for i := range this.Kvs {
		if !this.Kvs[i].Equal(that1.Kvs[i]) {
			return false
		}
	}
	return true
}
func (this *WithPrefixKeyResponse_KV) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*WithPrefixKeyResponse_KV)
	if !ok {
		that2, ok := that.(WithPrefixKeyResponse_KV)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if !bytes.Equal(this.Value, that1.Value) {
		return false
	}
	return true
}
func (this *RegisterTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterTracepointRequest)
	if !ok {
		that2, ok := that.(RegisterTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Requests) != len(that1.Requests) {
		return false
	}
	for i := range this.Requests {
		if !this.Requests[i].Equal(that1.Requests[i]) {
			return false
		}
	}
	return true
}
func (this *RegisterTracepointRequest_TracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterTracepointRequest_TracepointRequest)
	if !ok {
		that2, ok := that.(RegisterTracepointRequest_TracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TracepointDeployment.Equal(that1.TracepointDeployment) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.TTL.Equal(that1.TTL) {
		return false
	}
	return true
}
func (this *RegisterTracepointResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterTracepointResponse)
	if !ok {
		that2, ok := that.(RegisterTracepointResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Tracepoints) != len(that1.Tracepoints) {
		return false
	}
	for i := range this.Tracepoints {
		if !this.Tracepoints[i].Equal(that1.Tracepoints[i]) {
			return false
		}
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *RegisterTracepointResponse_TracepointStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterTracepointResponse_TracepointStatus)
	if !ok {
		that2, ok := that.(RegisterTracepointResponse_TracepointStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	return true
}
func (this *GetTracepointInfoRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetTracepointInfoRequest)
	if !ok {
		that2, ok := that.(GetTracepointInfoRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.IDs) != len(that1.IDs) {
		return false
	}
	for i := range this.IDs {
		if !this.IDs[i].Equal(that1.IDs[i]) {
			return false
		}
	}
	return true
}
func (this *GetTracepointInfoResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetTracepointInfoResponse)
	if !ok {
		that2, ok := that.(GetTracepointInfoResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Tracepoints) != len(that1.Tracepoints) {
		return false
	}
	for i := range this.Tracepoints {
		if !this.Tracepoints[i].Equal(that1.Tracepoints[i]) {
			return false
		}
	}
	return true
}
func (this *GetTracepointInfoResponse_TracepointState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetTracepointInfoResponse_TracepointState)
	if !ok {
		that2, ok := that.(GetTracepointInfoResponse_TracepointState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if len(this.Statuses) != len(that1.Statuses) {
		return false
	}
	for i := range this.Statuses {
		if !this.Statuses[i].Equal(that1.Statuses[i]) {
			return false
		}
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ExpectedState != that1.ExpectedState {
		return false
	}
	if len(this.SchemaNames) != len(that1.SchemaNames) {
		return false
	}
	for i := range this.SchemaNames {
		if this.SchemaNames[i] != that1.SchemaNames[i] {
			return false
		}
	}
	return true
}
func (this *RemoveTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RemoveTracepointRequest)
	if !ok {
		that2, ok := that.(RemoveTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Names) != len(that1.Names) {
		return false
	}
	for i := range this.Names {
		if this.Names[i] != that1.Names[i] {
			return false
		}
	}
	return true
}
func (this *RemoveTracepointResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RemoveTracepointResponse)
	if !ok {
		that2, ok := that.(RemoveTracepointResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *UpdateConfigRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateConfigRequest)
	if !ok {
		that2, ok := that.(UpdateConfigRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if this.AgentPodName != that1.AgentPodName {
		return false
	}
	return true
}
func (this *UpdateConfigResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateConfigResponse)
	if !ok {
		that2, ok := that.(UpdateConfigResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *GetScriptsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptsRequest)
	if !ok {
		that2, ok := that.(GetScriptsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *GetScriptsResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptsResponse)
	if !ok {
		that2, ok := that.(GetScriptsResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Scripts) != len(that1.Scripts) {
		return false
	}
	for i := range this.Scripts {
		if !this.Scripts[i].Equal(that1.Scripts[i]) {
			return false
		}
	}
	return true
}
func (this *AddOrUpdateScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AddOrUpdateScriptRequest)
	if !ok {
		that2, ok := that.(AddOrUpdateScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Script.Equal(that1.Script) {
		return false
	}
	return true
}
func (this *AddOrUpdateScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AddOrUpdateScriptResponse)
	if !ok {
		that2, ok := that.(AddOrUpdateScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *DeleteScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeleteScriptRequest)
	if !ok {
		that2, ok := that.(DeleteScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ScriptID.Equal(that1.ScriptID) {
		return false
	}
	return true
}
func (this *DeleteScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeleteScriptResponse)
	if !ok {
		that2, ok := that.(DeleteScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *SetScriptsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SetScriptsRequest)
	if !ok {
		that2, ok := that.(SetScriptsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Scripts) != len(that1.Scripts) {
		return false
	}
	for i := range this.Scripts {
		if !this.Scripts[i].Equal(that1.Scripts[i]) {
			return false
		}
	}
	return true
}
func (this *SetScriptsResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SetScriptsResponse)
	if !ok {
		that2, ok := that.(SetScriptsResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *ExecutionStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecutionStats)
	if !ok {
		that2, ok := that.(ExecutionStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ExecutionTimeNs != that1.ExecutionTimeNs {
		return false
	}
	if this.CompilationTimeNs != that1.CompilationTimeNs {
		return false
	}
	if this.BytesProcessed != that1.BytesProcessed {
		return false
	}
	if this.RecordsProcessed != that1.RecordsProcessed {
		return false
	}
	return true
}
func (this *RecordExecutionResultRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RecordExecutionResultRequest)
	if !ok {
		that2, ok := that.(RecordExecutionResultRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ScriptID.Equal(that1.ScriptID) {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	if that1.Result == nil {
		if this.Result != nil {
			return false
		}
	} else if this.Result == nil {
		return false
	} else if !this.Result.Equal(that1.Result) {
		return false
	}
	return true
}
func (this *RecordExecutionResultRequest_Error) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RecordExecutionResultRequest_Error)
	if !ok {
		that2, ok := that.(RecordExecutionResultRequest_Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *RecordExecutionResultRequest_ExecutionStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RecordExecutionResultRequest_ExecutionStats)
	if !ok {
		that2, ok := that.(RecordExecutionResultRequest_ExecutionStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ExecutionStats.Equal(that1.ExecutionStats) {
		return false
	}
	return true
}
func (this *RecordExecutionResultResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RecordExecutionResultResponse)
	if !ok {
		that2, ok := that.(RecordExecutionResultResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *GetAllExecutionResultsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetAllExecutionResultsRequest)
	if !ok {
		that2, ok := that.(GetAllExecutionResultsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *GetAllExecutionResultsResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetAllExecutionResultsResponse)
	if !ok {
		that2, ok := that.(GetAllExecutionResultsResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Results) != len(that1.Results) {
		return false
	}
	for i := range this.Results {
		if !this.Results[i].Equal(that1.Results[i]) {
			return false
		}
	}
	return true
}
func (this *GetAllExecutionResultsResponse_ExecutionResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetAllExecutionResultsResponse_ExecutionResult)
	if !ok {
		that2, ok := that.(GetAllExecutionResultsResponse_ExecutionResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ScriptID.Equal(that1.ScriptID) {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	if that1.Result == nil {
		if this.Result != nil {
			return false
		}
	} else if this.Result == nil {
		return false
	} else if !this.Result.Equal(that1.Result) {
		return false
	}
	return true
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_Error) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetAllExecutionResultsResponse_ExecutionResult_Error)
	if !ok {
		that2, ok := that.(GetAllExecutionResultsResponse_ExecutionResult_Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats)
	if !ok {
		that2, ok := that.(GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ExecutionStats.Equal(that1.ExecutionStats) {
		return false
	}
	return true
}
func (this *SchemaRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.SchemaRequest{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SchemaResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.SchemaResponse{")
	if this.Schema != nil {
		s = append(s, "Schema: "+fmt.Sprintf("%#v", this.Schema)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentInfoRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.AgentInfoRequest{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentInfoResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.AgentInfoResponse{")
	if this.Info != nil {
		s = append(s, "Info: "+fmt.Sprintf("%#v", this.Info)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.AgentMetadata{")
	if this.Agent != nil {
		s = append(s, "Agent: "+fmt.Sprintf("%#v", this.Agent)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	if this.CarnotInfo != nil {
		s = append(s, "CarnotInfo: "+fmt.Sprintf("%#v", this.CarnotInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentUpdatesRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.AgentUpdatesRequest{")
	if this.MaxUpdateInterval != nil {
		s = append(s, "MaxUpdateInterval: "+fmt.Sprintf("%#v", this.MaxUpdateInterval)+",\n")
	}
	s = append(s, "MaxUpdatesPerResponse: "+fmt.Sprintf("%#v", this.MaxUpdatesPerResponse)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.AgentUpdate{")
	if this.AgentID != nil {
		s = append(s, "AgentID: "+fmt.Sprintf("%#v", this.AgentID)+",\n")
	}
	if this.Update != nil {
		s = append(s, "Update: "+fmt.Sprintf("%#v", this.Update)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentUpdate_Deleted) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.AgentUpdate_Deleted{` +
		`Deleted:` + fmt.Sprintf("%#v", this.Deleted) + `}`}, ", ")
	return s
}
func (this *AgentUpdate_Agent) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.AgentUpdate_Agent{` +
		`Agent:` + fmt.Sprintf("%#v", this.Agent) + `}`}, ", ")
	return s
}
func (this *AgentUpdate_DataInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.AgentUpdate_DataInfo{` +
		`DataInfo:` + fmt.Sprintf("%#v", this.DataInfo) + `}`}, ", ")
	return s
}
func (this *AgentUpdatesResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.AgentUpdatesResponse{")
	if this.AgentUpdates != nil {
		s = append(s, "AgentUpdates: "+fmt.Sprintf("%#v", this.AgentUpdates)+",\n")
	}
	if this.AgentSchemas != nil {
		s = append(s, "AgentSchemas: "+fmt.Sprintf("%#v", this.AgentSchemas)+",\n")
	}
	s = append(s, "AgentSchemasUpdated: "+fmt.Sprintf("%#v", this.AgentSchemasUpdated)+",\n")
	s = append(s, "EndOfVersion: "+fmt.Sprintf("%#v", this.EndOfVersion)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *WithPrefixKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.WithPrefixKeyRequest{")
	s = append(s, "Prefix: "+fmt.Sprintf("%#v", this.Prefix)+",\n")
	s = append(s, "Proto: "+fmt.Sprintf("%#v", this.Proto)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *WithPrefixKeyResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.WithPrefixKeyResponse{")
	if this.Kvs != nil {
		s = append(s, "Kvs: "+fmt.Sprintf("%#v", this.Kvs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *WithPrefixKeyResponse_KV) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.WithPrefixKeyResponse_KV{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.RegisterTracepointRequest{")
	if this.Requests != nil {
		s = append(s, "Requests: "+fmt.Sprintf("%#v", this.Requests)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterTracepointRequest_TracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.RegisterTracepointRequest_TracepointRequest{")
	if this.TracepointDeployment != nil {
		s = append(s, "TracepointDeployment: "+fmt.Sprintf("%#v", this.TracepointDeployment)+",\n")
	}
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.TTL != nil {
		s = append(s, "TTL: "+fmt.Sprintf("%#v", this.TTL)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterTracepointResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.RegisterTracepointResponse{")
	if this.Tracepoints != nil {
		s = append(s, "Tracepoints: "+fmt.Sprintf("%#v", this.Tracepoints)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterTracepointResponse_TracepointStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.RegisterTracepointResponse_TracepointStatus{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetTracepointInfoRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.GetTracepointInfoRequest{")
	if this.IDs != nil {
		s = append(s, "IDs: "+fmt.Sprintf("%#v", this.IDs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetTracepointInfoResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.GetTracepointInfoResponse{")
	if this.Tracepoints != nil {
		s = append(s, "Tracepoints: "+fmt.Sprintf("%#v", this.Tracepoints)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetTracepointInfoResponse_TracepointState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&metadatapb.GetTracepointInfoResponse_TracepointState{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	if this.Statuses != nil {
		s = append(s, "Statuses: "+fmt.Sprintf("%#v", this.Statuses)+",\n")
	}
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ExpectedState: "+fmt.Sprintf("%#v", this.ExpectedState)+",\n")
	s = append(s, "SchemaNames: "+fmt.Sprintf("%#v", this.SchemaNames)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RemoveTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.RemoveTracepointRequest{")
	s = append(s, "Names: "+fmt.Sprintf("%#v", this.Names)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RemoveTracepointResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.RemoveTracepointResponse{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UpdateConfigRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.UpdateConfigRequest{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "AgentPodName: "+fmt.Sprintf("%#v", this.AgentPodName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UpdateConfigResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.UpdateConfigResponse{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptsRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.GetScriptsRequest{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptsResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.GetScriptsResponse{")
	keysForScripts := make([]string, 0, len(this.Scripts))
	for k, _ := range this.Scripts {
		keysForScripts = append(keysForScripts, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForScripts)
	mapStringForScripts := "map[string]*cvmsgspb.CronScript{"
	for _, k := range keysForScripts {
		mapStringForScripts += fmt.Sprintf("%#v: %#v,", k, this.Scripts[k])
	}
	mapStringForScripts += "}"
	if this.Scripts != nil {
		s = append(s, "Scripts: "+mapStringForScripts+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AddOrUpdateScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.AddOrUpdateScriptRequest{")
	if this.Script != nil {
		s = append(s, "Script: "+fmt.Sprintf("%#v", this.Script)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AddOrUpdateScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.AddOrUpdateScriptResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeleteScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.DeleteScriptRequest{")
	if this.ScriptID != nil {
		s = append(s, "ScriptID: "+fmt.Sprintf("%#v", this.ScriptID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeleteScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.DeleteScriptResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SetScriptsRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.SetScriptsRequest{")
	keysForScripts := make([]string, 0, len(this.Scripts))
	for k, _ := range this.Scripts {
		keysForScripts = append(keysForScripts, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForScripts)
	mapStringForScripts := "map[string]*cvmsgspb.CronScript{"
	for _, k := range keysForScripts {
		mapStringForScripts += fmt.Sprintf("%#v: %#v,", k, this.Scripts[k])
	}
	mapStringForScripts += "}"
	if this.Scripts != nil {
		s = append(s, "Scripts: "+mapStringForScripts+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SetScriptsResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.SetScriptsResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecutionStats) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.ExecutionStats{")
	s = append(s, "ExecutionTimeNs: "+fmt.Sprintf("%#v", this.ExecutionTimeNs)+",\n")
	s = append(s, "CompilationTimeNs: "+fmt.Sprintf("%#v", this.CompilationTimeNs)+",\n")
	s = append(s, "BytesProcessed: "+fmt.Sprintf("%#v", this.BytesProcessed)+",\n")
	s = append(s, "RecordsProcessed: "+fmt.Sprintf("%#v", this.RecordsProcessed)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RecordExecutionResultRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.RecordExecutionResultRequest{")
	if this.ScriptID != nil {
		s = append(s, "ScriptID: "+fmt.Sprintf("%#v", this.ScriptID)+",\n")
	}
	if this.Timestamp != nil {
		s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	}
	if this.Result != nil {
		s = append(s, "Result: "+fmt.Sprintf("%#v", this.Result)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RecordExecutionResultRequest_Error) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.RecordExecutionResultRequest_Error{` +
		`Error:` + fmt.Sprintf("%#v", this.Error) + `}`}, ", ")
	return s
}
func (this *RecordExecutionResultRequest_ExecutionStats) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.RecordExecutionResultRequest_ExecutionStats{` +
		`ExecutionStats:` + fmt.Sprintf("%#v", this.ExecutionStats) + `}`}, ", ")
	return s
}
func (this *RecordExecutionResultResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.RecordExecutionResultResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetAllExecutionResultsRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&metadatapb.GetAllExecutionResultsRequest{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetAllExecutionResultsResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.GetAllExecutionResultsResponse{")
	if this.Results != nil {
		s = append(s, "Results: "+fmt.Sprintf("%#v", this.Results)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetAllExecutionResultsResponse_ExecutionResult) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.GetAllExecutionResultsResponse_ExecutionResult{")
	if this.ScriptID != nil {
		s = append(s, "ScriptID: "+fmt.Sprintf("%#v", this.ScriptID)+",\n")
	}
	if this.Timestamp != nil {
		s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	}
	if this.Result != nil {
		s = append(s, "Result: "+fmt.Sprintf("%#v", this.Result)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_Error) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.GetAllExecutionResultsResponse_ExecutionResult_Error{` +
		`Error:` + fmt.Sprintf("%#v", this.Error) + `}`}, ", ")
	return s
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats{` +
		`ExecutionStats:` + fmt.Sprintf("%#v", this.ExecutionStats) + `}`}, ", ")
	return s
}
func valueToGoStringService(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MetadataServiceClient is the client API for MetadataService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MetadataServiceClient interface {
	GetAgentUpdates(ctx context.Context, in *AgentUpdatesRequest, opts ...grpc.CallOption) (MetadataService_GetAgentUpdatesClient, error)
	GetSchemas(ctx context.Context, in *SchemaRequest, opts ...grpc.CallOption) (*SchemaResponse, error)
	GetAgentInfo(ctx context.Context, in *AgentInfoRequest, opts ...grpc.CallOption) (*AgentInfoResponse, error)
	GetWithPrefixKey(ctx context.Context, in *WithPrefixKeyRequest, opts ...grpc.CallOption) (*WithPrefixKeyResponse, error)
}

type metadataServiceClient struct {
	cc *grpc.ClientConn
}

func NewMetadataServiceClient(cc *grpc.ClientConn) MetadataServiceClient {
	return &metadataServiceClient{cc}
}

func (c *metadataServiceClient) GetAgentUpdates(ctx context.Context, in *AgentUpdatesRequest, opts ...grpc.CallOption) (MetadataService_GetAgentUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MetadataService_serviceDesc.Streams[0], "/px.vizier.services.metadata.MetadataService/GetAgentUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &metadataServiceGetAgentUpdatesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type MetadataService_GetAgentUpdatesClient interface {
	Recv() (*AgentUpdatesResponse, error)
	grpc.ClientStream
}

type metadataServiceGetAgentUpdatesClient struct {
	grpc.ClientStream
}

func (x *metadataServiceGetAgentUpdatesClient) Recv() (*AgentUpdatesResponse, error) {
	m := new(AgentUpdatesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *metadataServiceClient) GetSchemas(ctx context.Context, in *SchemaRequest, opts ...grpc.CallOption) (*SchemaResponse, error) {
	out := new(SchemaResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataService/GetSchemas", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metadataServiceClient) GetAgentInfo(ctx context.Context, in *AgentInfoRequest, opts ...grpc.CallOption) (*AgentInfoResponse, error) {
	out := new(AgentInfoResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataService/GetAgentInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metadataServiceClient) GetWithPrefixKey(ctx context.Context, in *WithPrefixKeyRequest, opts ...grpc.CallOption) (*WithPrefixKeyResponse, error) {
	out := new(WithPrefixKeyResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataService/GetWithPrefixKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MetadataServiceServer is the server API for MetadataService service.
type MetadataServiceServer interface {
	GetAgentUpdates(*AgentUpdatesRequest, MetadataService_GetAgentUpdatesServer) error
	GetSchemas(context.Context, *SchemaRequest) (*SchemaResponse, error)
	GetAgentInfo(context.Context, *AgentInfoRequest) (*AgentInfoResponse, error)
	GetWithPrefixKey(context.Context, *WithPrefixKeyRequest) (*WithPrefixKeyResponse, error)
}

// UnimplementedMetadataServiceServer can be embedded to have forward compatible implementations.
type UnimplementedMetadataServiceServer struct {
}

func (*UnimplementedMetadataServiceServer) GetAgentUpdates(req *AgentUpdatesRequest, srv MetadataService_GetAgentUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAgentUpdates not implemented")
}
func (*UnimplementedMetadataServiceServer) GetSchemas(ctx context.Context, req *SchemaRequest) (*SchemaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSchemas not implemented")
}
func (*UnimplementedMetadataServiceServer) GetAgentInfo(ctx context.Context, req *AgentInfoRequest) (*AgentInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgentInfo not implemented")
}
func (*UnimplementedMetadataServiceServer) GetWithPrefixKey(ctx context.Context, req *WithPrefixKeyRequest) (*WithPrefixKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWithPrefixKey not implemented")
}

func RegisterMetadataServiceServer(s *grpc.Server, srv MetadataServiceServer) {
	s.RegisterService(&_MetadataService_serviceDesc, srv)
}

func _MetadataService_GetAgentUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AgentUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MetadataServiceServer).GetAgentUpdates(m, &metadataServiceGetAgentUpdatesServer{stream})
}

type MetadataService_GetAgentUpdatesServer interface {
	Send(*AgentUpdatesResponse) error
	grpc.ServerStream
}

type metadataServiceGetAgentUpdatesServer struct {
	grpc.ServerStream
}

func (x *metadataServiceGetAgentUpdatesServer) Send(m *AgentUpdatesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _MetadataService_GetSchemas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataServiceServer).GetSchemas(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataService/GetSchemas",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataServiceServer).GetSchemas(ctx, req.(*SchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MetadataService_GetAgentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataServiceServer).GetAgentInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataService/GetAgentInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataServiceServer).GetAgentInfo(ctx, req.(*AgentInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MetadataService_GetWithPrefixKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithPrefixKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataServiceServer).GetWithPrefixKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataService/GetWithPrefixKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataServiceServer).GetWithPrefixKey(ctx, req.(*WithPrefixKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MetadataService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.vizier.services.metadata.MetadataService",
	HandlerType: (*MetadataServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSchemas",
			Handler:    _MetadataService_GetSchemas_Handler,
		},
		{
			MethodName: "GetAgentInfo",
			Handler:    _MetadataService_GetAgentInfo_Handler,
		},
		{
			MethodName: "GetWithPrefixKey",
			Handler:    _MetadataService_GetWithPrefixKey_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAgentUpdates",
			Handler:       _MetadataService_GetAgentUpdates_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "src/vizier/services/metadata/metadatapb/service.proto",
}

// MetadataTracepointServiceClient is the client API for MetadataTracepointService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MetadataTracepointServiceClient interface {
	RegisterTracepoint(ctx context.Context, in *RegisterTracepointRequest, opts ...grpc.CallOption) (*RegisterTracepointResponse, error)
	GetTracepointInfo(ctx context.Context, in *GetTracepointInfoRequest, opts ...grpc.CallOption) (*GetTracepointInfoResponse, error)
	RemoveTracepoint(ctx context.Context, in *RemoveTracepointRequest, opts ...grpc.CallOption) (*RemoveTracepointResponse, error)
}

type metadataTracepointServiceClient struct {
	cc *grpc.ClientConn
}

func NewMetadataTracepointServiceClient(cc *grpc.ClientConn) MetadataTracepointServiceClient {
	return &metadataTracepointServiceClient{cc}
}

func (c *metadataTracepointServiceClient) RegisterTracepoint(ctx context.Context, in *RegisterTracepointRequest, opts ...grpc.CallOption) (*RegisterTracepointResponse, error) {
	out := new(RegisterTracepointResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataTracepointService/RegisterTracepoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metadataTracepointServiceClient) GetTracepointInfo(ctx context.Context, in *GetTracepointInfoRequest, opts ...grpc.CallOption) (*GetTracepointInfoResponse, error) {
	out := new(GetTracepointInfoResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataTracepointService/GetTracepointInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metadataTracepointServiceClient) RemoveTracepoint(ctx context.Context, in *RemoveTracepointRequest, opts ...grpc.CallOption) (*RemoveTracepointResponse, error) {
	out := new(RemoveTracepointResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataTracepointService/RemoveTracepoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MetadataTracepointServiceServer is the server API for MetadataTracepointService service.
type MetadataTracepointServiceServer interface {
	RegisterTracepoint(context.Context, *RegisterTracepointRequest) (*RegisterTracepointResponse, error)
	GetTracepointInfo(context.Context, *GetTracepointInfoRequest) (*GetTracepointInfoResponse, error)
	RemoveTracepoint(context.Context, *RemoveTracepointRequest) (*RemoveTracepointResponse, error)
}

// UnimplementedMetadataTracepointServiceServer can be embedded to have forward compatible implementations.
type UnimplementedMetadataTracepointServiceServer struct {
}

func (*UnimplementedMetadataTracepointServiceServer) RegisterTracepoint(ctx context.Context, req *RegisterTracepointRequest) (*RegisterTracepointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterTracepoint not implemented")
}
func (*UnimplementedMetadataTracepointServiceServer) GetTracepointInfo(ctx context.Context, req *GetTracepointInfoRequest) (*GetTracepointInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTracepointInfo not implemented")
}
func (*UnimplementedMetadataTracepointServiceServer) RemoveTracepoint(ctx context.Context, req *RemoveTracepointRequest) (*RemoveTracepointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveTracepoint not implemented")
}

func RegisterMetadataTracepointServiceServer(s *grpc.Server, srv MetadataTracepointServiceServer) {
	s.RegisterService(&_MetadataTracepointService_serviceDesc, srv)
}

func _MetadataTracepointService_RegisterTracepoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterTracepointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataTracepointServiceServer).RegisterTracepoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataTracepointService/RegisterTracepoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataTracepointServiceServer).RegisterTracepoint(ctx, req.(*RegisterTracepointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MetadataTracepointService_GetTracepointInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTracepointInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataTracepointServiceServer).GetTracepointInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataTracepointService/GetTracepointInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataTracepointServiceServer).GetTracepointInfo(ctx, req.(*GetTracepointInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MetadataTracepointService_RemoveTracepoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveTracepointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataTracepointServiceServer).RemoveTracepoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataTracepointService/RemoveTracepoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataTracepointServiceServer).RemoveTracepoint(ctx, req.(*RemoveTracepointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MetadataTracepointService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.vizier.services.metadata.MetadataTracepointService",
	HandlerType: (*MetadataTracepointServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterTracepoint",
			Handler:    _MetadataTracepointService_RegisterTracepoint_Handler,
		},
		{
			MethodName: "GetTracepointInfo",
			Handler:    _MetadataTracepointService_GetTracepointInfo_Handler,
		},
		{
			MethodName: "RemoveTracepoint",
			Handler:    _MetadataTracepointService_RemoveTracepoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/vizier/services/metadata/metadatapb/service.proto",
}

// MetadataConfigServiceClient is the client API for MetadataConfigService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MetadataConfigServiceClient interface {
	UpdateConfig(ctx context.Context, in *UpdateConfigRequest, opts ...grpc.CallOption) (*UpdateConfigResponse, error)
}

type metadataConfigServiceClient struct {
	cc *grpc.ClientConn
}

func NewMetadataConfigServiceClient(cc *grpc.ClientConn) MetadataConfigServiceClient {
	return &metadataConfigServiceClient{cc}
}

func (c *metadataConfigServiceClient) UpdateConfig(ctx context.Context, in *UpdateConfigRequest, opts ...grpc.CallOption) (*UpdateConfigResponse, error) {
	out := new(UpdateConfigResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.MetadataConfigService/UpdateConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MetadataConfigServiceServer is the server API for MetadataConfigService service.
type MetadataConfigServiceServer interface {
	UpdateConfig(context.Context, *UpdateConfigRequest) (*UpdateConfigResponse, error)
}

// UnimplementedMetadataConfigServiceServer can be embedded to have forward compatible implementations.
type UnimplementedMetadataConfigServiceServer struct {
}

func (*UnimplementedMetadataConfigServiceServer) UpdateConfig(ctx context.Context, req *UpdateConfigRequest) (*UpdateConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateConfig not implemented")
}

func RegisterMetadataConfigServiceServer(s *grpc.Server, srv MetadataConfigServiceServer) {
	s.RegisterService(&_MetadataConfigService_serviceDesc, srv)
}

func _MetadataConfigService_UpdateConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetadataConfigServiceServer).UpdateConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.MetadataConfigService/UpdateConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetadataConfigServiceServer).UpdateConfig(ctx, req.(*UpdateConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MetadataConfigService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.vizier.services.metadata.MetadataConfigService",
	HandlerType: (*MetadataConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateConfig",
			Handler:    _MetadataConfigService_UpdateConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/vizier/services/metadata/metadatapb/service.proto",
}

// CronScriptStoreServiceClient is the client API for CronScriptStoreService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CronScriptStoreServiceClient interface {
	GetScripts(ctx context.Context, in *GetScriptsRequest, opts ...grpc.CallOption) (*GetScriptsResponse, error)
	AddOrUpdateScript(ctx context.Context, in *AddOrUpdateScriptRequest, opts ...grpc.CallOption) (*AddOrUpdateScriptResponse, error)
	DeleteScript(ctx context.Context, in *DeleteScriptRequest, opts ...grpc.CallOption) (*DeleteScriptResponse, error)
	SetScripts(ctx context.Context, in *SetScriptsRequest, opts ...grpc.CallOption) (*SetScriptsResponse, error)
	RecordExecutionResult(ctx context.Context, in *RecordExecutionResultRequest, opts ...grpc.CallOption) (*RecordExecutionResultResponse, error)
	GetAllExecutionResults(ctx context.Context, in *GetAllExecutionResultsRequest, opts ...grpc.CallOption) (*GetAllExecutionResultsResponse, error)
}

type cronScriptStoreServiceClient struct {
	cc *grpc.ClientConn
}

func NewCronScriptStoreServiceClient(cc *grpc.ClientConn) CronScriptStoreServiceClient {
	return &cronScriptStoreServiceClient{cc}
}

func (c *cronScriptStoreServiceClient) GetScripts(ctx context.Context, in *GetScriptsRequest, opts ...grpc.CallOption) (*GetScriptsResponse, error) {
	out := new(GetScriptsResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/GetScripts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptStoreServiceClient) AddOrUpdateScript(ctx context.Context, in *AddOrUpdateScriptRequest, opts ...grpc.CallOption) (*AddOrUpdateScriptResponse, error) {
	out := new(AddOrUpdateScriptResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/AddOrUpdateScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptStoreServiceClient) DeleteScript(ctx context.Context, in *DeleteScriptRequest, opts ...grpc.CallOption) (*DeleteScriptResponse, error) {
	out := new(DeleteScriptResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/DeleteScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptStoreServiceClient) SetScripts(ctx context.Context, in *SetScriptsRequest, opts ...grpc.CallOption) (*SetScriptsResponse, error) {
	out := new(SetScriptsResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/SetScripts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptStoreServiceClient) RecordExecutionResult(ctx context.Context, in *RecordExecutionResultRequest, opts ...grpc.CallOption) (*RecordExecutionResultResponse, error) {
	out := new(RecordExecutionResultResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/RecordExecutionResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptStoreServiceClient) GetAllExecutionResults(ctx context.Context, in *GetAllExecutionResultsRequest, opts ...grpc.CallOption) (*GetAllExecutionResultsResponse, error) {
	out := new(GetAllExecutionResultsResponse)
	err := c.cc.Invoke(ctx, "/px.vizier.services.metadata.CronScriptStoreService/GetAllExecutionResults", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CronScriptStoreServiceServer is the server API for CronScriptStoreService service.
type CronScriptStoreServiceServer interface {
	GetScripts(context.Context, *GetScriptsRequest) (*GetScriptsResponse, error)
	AddOrUpdateScript(context.Context, *AddOrUpdateScriptRequest) (*AddOrUpdateScriptResponse, error)
	DeleteScript(context.Context, *DeleteScriptRequest) (*DeleteScriptResponse, error)
	SetScripts(context.Context, *SetScriptsRequest) (*SetScriptsResponse, error)
	RecordExecutionResult(context.Context, *RecordExecutionResultRequest) (*RecordExecutionResultResponse, error)
	GetAllExecutionResults(context.Context, *GetAllExecutionResultsRequest) (*GetAllExecutionResultsResponse, error)
}

// UnimplementedCronScriptStoreServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCronScriptStoreServiceServer struct {
}

func (*UnimplementedCronScriptStoreServiceServer) GetScripts(ctx context.Context, req *GetScriptsRequest) (*GetScriptsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetScripts not implemented")
}
func (*UnimplementedCronScriptStoreServiceServer) AddOrUpdateScript(ctx context.Context, req *AddOrUpdateScriptRequest) (*AddOrUpdateScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddOrUpdateScript not implemented")
}
func (*UnimplementedCronScriptStoreServiceServer) DeleteScript(ctx context.Context, req *DeleteScriptRequest) (*DeleteScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteScript not implemented")
}
func (*UnimplementedCronScriptStoreServiceServer) SetScripts(ctx context.Context, req *SetScriptsRequest) (*SetScriptsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetScripts not implemented")
}
func (*UnimplementedCronScriptStoreServiceServer) RecordExecutionResult(ctx context.Context, req *RecordExecutionResultRequest) (*RecordExecutionResultResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RecordExecutionResult not implemented")
}
func (*UnimplementedCronScriptStoreServiceServer) GetAllExecutionResults(ctx context.Context, req *GetAllExecutionResultsRequest) (*GetAllExecutionResultsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllExecutionResults not implemented")
}

func RegisterCronScriptStoreServiceServer(s *grpc.Server, srv CronScriptStoreServiceServer) {
	s.RegisterService(&_CronScriptStoreService_serviceDesc, srv)
}

func _CronScriptStoreService_GetScripts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetScriptsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).GetScripts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/GetScripts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).GetScripts(ctx, req.(*GetScriptsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptStoreService_AddOrUpdateScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddOrUpdateScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).AddOrUpdateScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/AddOrUpdateScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).AddOrUpdateScript(ctx, req.(*AddOrUpdateScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptStoreService_DeleteScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).DeleteScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/DeleteScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).DeleteScript(ctx, req.(*DeleteScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptStoreService_SetScripts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetScriptsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).SetScripts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/SetScripts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).SetScripts(ctx, req.(*SetScriptsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptStoreService_RecordExecutionResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RecordExecutionResultRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).RecordExecutionResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/RecordExecutionResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).RecordExecutionResult(ctx, req.(*RecordExecutionResultRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptStoreService_GetAllExecutionResults_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAllExecutionResultsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptStoreServiceServer).GetAllExecutionResults(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.vizier.services.metadata.CronScriptStoreService/GetAllExecutionResults",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptStoreServiceServer).GetAllExecutionResults(ctx, req.(*GetAllExecutionResultsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CronScriptStoreService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.vizier.services.metadata.CronScriptStoreService",
	HandlerType: (*CronScriptStoreServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetScripts",
			Handler:    _CronScriptStoreService_GetScripts_Handler,
		},
		{
			MethodName: "AddOrUpdateScript",
			Handler:    _CronScriptStoreService_AddOrUpdateScript_Handler,
		},
		{
			MethodName: "DeleteScript",
			Handler:    _CronScriptStoreService_DeleteScript_Handler,
		},
		{
			MethodName: "SetScripts",
			Handler:    _CronScriptStoreService_SetScripts_Handler,
		},
		{
			MethodName: "RecordExecutionResult",
			Handler:    _CronScriptStoreService_RecordExecutionResult_Handler,
		},
		{
			MethodName: "GetAllExecutionResults",
			Handler:    _CronScriptStoreService_GetAllExecutionResults_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/vizier/services/metadata/metadatapb/service.proto",
}

func (m *SchemaRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SchemaRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SchemaRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *SchemaResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SchemaResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SchemaResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Schema != nil {
		{
			size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *AgentInfoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentInfoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AgentInfoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Info) > 0 {
		for iNdEx := len(m.Info) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Info[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AgentMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CarnotInfo != nil {
		{
			size, err := m.CarnotInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Agent != nil {
		{
			size, err := m.Agent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AgentUpdatesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentUpdatesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxUpdatesPerResponse != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.MaxUpdatesPerResponse))
		i--
		dAtA[i] = 0x10
	}
	if m.MaxUpdateInterval != nil {
		{
			size, err := m.MaxUpdateInterval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AgentUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Update != nil {
		{
			size := m.Update.Size()
			i -= size
			if _, err := m.Update.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.AgentID != nil {
		{
			size, err := m.AgentID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AgentUpdate_Deleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdate_Deleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.Deleted {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *AgentUpdate_Agent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdate_Agent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Agent != nil {
		{
			size, err := m.Agent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *AgentUpdate_DataInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdate_DataInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DataInfo != nil {
		{
			size, err := m.DataInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *AgentUpdatesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentUpdatesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdatesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndOfVersion {
		i--
		if m.EndOfVersion {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.AgentSchemasUpdated {
		i--
		if m.AgentSchemasUpdated {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.AgentSchemas) > 0 {
		for iNdEx := len(m.AgentSchemas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AgentSchemas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AgentUpdates) > 0 {
		for iNdEx := len(m.AgentUpdates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AgentUpdates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *WithPrefixKeyRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WithPrefixKeyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WithPrefixKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Proto) > 0 {
		i -= len(m.Proto)
		copy(dAtA[i:], m.Proto)
		i = encodeVarintService(dAtA, i, uint64(len(m.Proto)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Prefix) > 0 {
		i -= len(m.Prefix)
		copy(dAtA[i:], m.Prefix)
		i = encodeVarintService(dAtA, i, uint64(len(m.Prefix)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WithPrefixKeyResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WithPrefixKeyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WithPrefixKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Kvs) > 0 {
		for iNdEx := len(m.Kvs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Kvs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *WithPrefixKeyResponse_KV) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WithPrefixKeyResponse_KV) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WithPrefixKeyResponse_KV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintService(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintService(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTracepointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for iNdEx := len(m.Requests) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Requests[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTracepointRequest_TracepointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTracepointRequest_TracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTracepointRequest_TracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TTL != nil {
		{
			size, err := m.TTL.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintService(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.TracepointDeployment != nil {
		{
			size, err := m.TracepointDeployment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTracepointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTracepointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTracepointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Tracepoints) > 0 {
		for iNdEx := len(m.Tracepoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tracepoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTracepointResponse_TracepointStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTracepointResponse_TracepointStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTracepointResponse_TracepointStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintService(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetTracepointInfoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTracepointInfoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTracepointInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for iNdEx := len(m.IDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.IDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetTracepointInfoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTracepointInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTracepointInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tracepoints) > 0 {
		for iNdEx := len(m.Tracepoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tracepoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetTracepointInfoResponse_TracepointState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTracepointInfoResponse_TracepointState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTracepointInfoResponse_TracepointState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SchemaNames) > 0 {
		for iNdEx := len(m.SchemaNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SchemaNames[iNdEx])
			copy(dAtA[i:], m.SchemaNames[iNdEx])
			i = encodeVarintService(dAtA, i, uint64(len(m.SchemaNames[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.ExpectedState != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ExpectedState))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintService(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Statuses) > 0 {
		for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Statuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.State != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveTracepointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Names) > 0 {
		for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Names[iNdEx])
			copy(dAtA[i:], m.Names[iNdEx])
			i = encodeVarintService(dAtA, i, uint64(len(m.Names[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RemoveTracepointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveTracepointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveTracepointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateConfigRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AgentPodName) > 0 {
		i -= len(m.AgentPodName)
		copy(dAtA[i:], m.AgentPodName)
		i = encodeVarintService(dAtA, i, uint64(len(m.AgentPodName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintService(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintService(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateConfigResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateConfigResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetScriptsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetScriptsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for k := range m.Scripts {
			v := m.Scripts[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintService(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintService(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintService(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AddOrUpdateScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddOrUpdateScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddOrUpdateScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Script != nil {
		{
			size, err := m.Script.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddOrUpdateScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddOrUpdateScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddOrUpdateScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DeleteScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ScriptID != nil {
		{
			size, err := m.ScriptID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *SetScriptsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetScriptsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetScriptsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for k := range m.Scripts {
			v := m.Scripts[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintService(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintService(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintService(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *SetScriptsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetScriptsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetScriptsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ExecutionStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecutionStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecutionStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RecordsProcessed != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.RecordsProcessed))
		i--
		dAtA[i] = 0x20
	}
	if m.BytesProcessed != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.BytesProcessed))
		i--
		dAtA[i] = 0x18
	}
	if m.CompilationTimeNs != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.CompilationTimeNs))
		i--
		dAtA[i] = 0x10
	}
	if m.ExecutionTimeNs != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ExecutionTimeNs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RecordExecutionResultRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordExecutionResultRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordExecutionResultRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Result != nil {
		{
			size := m.Result.Size()
			i -= size
			if _, err := m.Result.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ScriptID != nil {
		{
			size, err := m.ScriptID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RecordExecutionResultRequest_Error) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordExecutionResultRequest_Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *RecordExecutionResultRequest_ExecutionStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordExecutionResultRequest_ExecutionStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ExecutionStats != nil {
		{
			size, err := m.ExecutionStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *RecordExecutionResultResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordExecutionResultResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordExecutionResultResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetAllExecutionResultsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAllExecutionResultsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetAllExecutionResultsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetAllExecutionResultsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAllExecutionResultsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetAllExecutionResultsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Results) > 0 {
		for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Result != nil {
		{
			size := m.Result.Size()
			i -= size
			if _, err := m.Result.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ScriptID != nil {
		{
			size, err := m.ScriptID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetAllExecutionResultsResponse_ExecutionResult_Error) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetAllExecutionResultsResponse_ExecutionResult_Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ExecutionStats != nil {
		{
			size, err := m.ExecutionStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	offset -= sovService(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *SchemaRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *SchemaResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Schema != nil {
		l = m.Schema.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *AgentInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AgentInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Info) > 0 {
		for _, e := range m.Info {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *AgentMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Agent != nil {
		l = m.Agent.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.CarnotInfo != nil {
		l = m.CarnotInfo.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *AgentUpdatesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxUpdateInterval != nil {
		l = m.MaxUpdateInterval.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.MaxUpdatesPerResponse != 0 {
		n += 1 + sovService(uint64(m.MaxUpdatesPerResponse))
	}
	return n
}

func (m *AgentUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AgentID != nil {
		l = m.AgentID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Update != nil {
		n += m.Update.Size()
	}
	return n
}

func (m *AgentUpdate_Deleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *AgentUpdate_Agent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Agent != nil {
		l = m.Agent.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *AgentUpdate_DataInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DataInfo != nil {
		l = m.DataInfo.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *AgentUpdatesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AgentUpdates) > 0 {
		for _, e := range m.AgentUpdates {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if len(m.AgentSchemas) > 0 {
		for _, e := range m.AgentSchemas {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if m.AgentSchemasUpdated {
		n += 2
	}
	if m.EndOfVersion {
		n += 2
	}
	return n
}

func (m *WithPrefixKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Prefix)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Proto)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *WithPrefixKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Kvs) > 0 {
		for _, e := range m.Kvs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *WithPrefixKeyResponse_KV) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *RegisterTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, e := range m.Requests {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *RegisterTracepointRequest_TracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TracepointDeployment != nil {
		l = m.TracepointDeployment.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.TTL != nil {
		l = m.TTL.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *RegisterTracepointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tracepoints) > 0 {
		for _, e := range m.Tracepoints {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *RegisterTracepointResponse_TracepointStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetTracepointInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, e := range m.IDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetTracepointInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tracepoints) > 0 {
		for _, e := range m.Tracepoints {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetTracepointInfoResponse_TracepointState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovService(uint64(m.State))
	}
	if len(m.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.ExpectedState != 0 {
		n += 1 + sovService(uint64(m.ExpectedState))
	}
	if len(m.SchemaNames) > 0 {
		for _, s := range m.SchemaNames {
			l = len(s)
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *RemoveTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Names) > 0 {
		for _, s := range m.Names {
			l = len(s)
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *RemoveTracepointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *UpdateConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.AgentPodName)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *UpdateConfigResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetScriptsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetScriptsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for k, v := range m.Scripts {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovService(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovService(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *AddOrUpdateScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Script != nil {
		l = m.Script.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *AddOrUpdateScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DeleteScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScriptID != nil {
		l = m.ScriptID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *DeleteScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *SetScriptsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for k, v := range m.Scripts {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovService(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovService(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *SetScriptsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ExecutionStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExecutionTimeNs != 0 {
		n += 1 + sovService(uint64(m.ExecutionTimeNs))
	}
	if m.CompilationTimeNs != 0 {
		n += 1 + sovService(uint64(m.CompilationTimeNs))
	}
	if m.BytesProcessed != 0 {
		n += 1 + sovService(uint64(m.BytesProcessed))
	}
	if m.RecordsProcessed != 0 {
		n += 1 + sovService(uint64(m.RecordsProcessed))
	}
	return n
}

func (m *RecordExecutionResultRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScriptID != nil {
		l = m.ScriptID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Result != nil {
		n += m.Result.Size()
	}
	return n
}

func (m *RecordExecutionResultRequest_Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *RecordExecutionResultRequest_ExecutionStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExecutionStats != nil {
		l = m.ExecutionStats.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *RecordExecutionResultResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetAllExecutionResultsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetAllExecutionResultsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Results) > 0 {
		for _, e := range m.Results {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetAllExecutionResultsResponse_ExecutionResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScriptID != nil {
		l = m.ScriptID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Result != nil {
		n += m.Result.Size()
	}
	return n
}

func (m *GetAllExecutionResultsResponse_ExecutionResult_Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExecutionStats != nil {
		l = m.ExecutionStats.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func sovService(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *SchemaRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SchemaRequest{`,
		`}`,
	}, "")
	return s
}
func (this *SchemaResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SchemaResponse{`,
		`Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "Schema", "schemapb.Schema", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentInfoRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentInfoRequest{`,
		`}`,
	}, "")
	return s
}
func (this *AgentInfoResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForInfo := "[]*AgentMetadata{"
	for _, f := range this.Info {
		repeatedStringForInfo += strings.Replace(f.String(), "AgentMetadata", "AgentMetadata", 1) + ","
	}
	repeatedStringForInfo += "}"
	s := strings.Join([]string{`&AgentInfoResponse{`,
		`Info:` + repeatedStringForInfo + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentMetadata{`,
		`Agent:` + strings.Replace(fmt.Sprintf("%v", this.Agent), "Agent", "agentpb.Agent", 1) + `,`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "AgentStatus", "agentpb.AgentStatus", 1) + `,`,
		`CarnotInfo:` + strings.Replace(fmt.Sprintf("%v", this.CarnotInfo), "CarnotInfo", "distributedpb.CarnotInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdatesRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentUpdatesRequest{`,
		`MaxUpdateInterval:` + strings.Replace(fmt.Sprintf("%v", this.MaxUpdateInterval), "Duration", "types.Duration", 1) + `,`,
		`MaxUpdatesPerResponse:` + fmt.Sprintf("%v", this.MaxUpdatesPerResponse) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentUpdate{`,
		`AgentID:` + strings.Replace(fmt.Sprintf("%v", this.AgentID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Update:` + fmt.Sprintf("%v", this.Update) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdate_Deleted) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentUpdate_Deleted{`,
		`Deleted:` + fmt.Sprintf("%v", this.Deleted) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdate_Agent) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentUpdate_Agent{`,
		`Agent:` + strings.Replace(fmt.Sprintf("%v", this.Agent), "Agent", "agentpb.Agent", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdate_DataInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentUpdate_DataInfo{`,
		`DataInfo:` + strings.Replace(fmt.Sprintf("%v", this.DataInfo), "AgentDataInfo", "messagespb.AgentDataInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdatesResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAgentUpdates := "[]*AgentUpdate{"
	for _, f := range this.AgentUpdates {
		repeatedStringForAgentUpdates += strings.Replace(f.String(), "AgentUpdate", "AgentUpdate", 1) + ","
	}
	repeatedStringForAgentUpdates += "}"
	repeatedStringForAgentSchemas := "[]*SchemaInfo{"
	for _, f := range this.AgentSchemas {
		repeatedStringForAgentSchemas += strings.Replace(fmt.Sprintf("%v", f), "SchemaInfo", "distributedpb.SchemaInfo", 1) + ","
	}
	repeatedStringForAgentSchemas += "}"
	s := strings.Join([]string{`&AgentUpdatesResponse{`,
		`AgentUpdates:` + repeatedStringForAgentUpdates + `,`,
		`AgentSchemas:` + repeatedStringForAgentSchemas + `,`,
		`AgentSchemasUpdated:` + fmt.Sprintf("%v", this.AgentSchemasUpdated) + `,`,
		`EndOfVersion:` + fmt.Sprintf("%v", this.EndOfVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WithPrefixKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WithPrefixKeyRequest{`,
		`Prefix:` + fmt.Sprintf("%v", this.Prefix) + `,`,
		`Proto:` + fmt.Sprintf("%v", this.Proto) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WithPrefixKeyResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForKvs := "[]*WithPrefixKeyResponse_KV{"
	for _, f := range this.Kvs {
		repeatedStringForKvs += strings.Replace(fmt.Sprintf("%v", f), "WithPrefixKeyResponse_KV", "WithPrefixKeyResponse_KV", 1) + ","
	}
	repeatedStringForKvs += "}"
	s := strings.Join([]string{`&WithPrefixKeyResponse{`,
		`Kvs:` + repeatedStringForKvs + `,`,
		`}`,
	}, "")
	return s
}
func (this *WithPrefixKeyResponse_KV) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WithPrefixKeyResponse_KV{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForRequests := "[]*RegisterTracepointRequest_TracepointRequest{"
	for _, f := range this.Requests {
		repeatedStringForRequests += strings.Replace(fmt.Sprintf("%v", f), "RegisterTracepointRequest_TracepointRequest", "RegisterTracepointRequest_TracepointRequest", 1) + ","
	}
	repeatedStringForRequests += "}"
	s := strings.Join([]string{`&RegisterTracepointRequest{`,
		`Requests:` + repeatedStringForRequests + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterTracepointRequest_TracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterTracepointRequest_TracepointRequest{`,
		`TracepointDeployment:` + strings.Replace(fmt.Sprintf("%v", this.TracepointDeployment), "TracepointDeployment", "logicalpb.TracepointDeployment", 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`TTL:` + strings.Replace(fmt.Sprintf("%v", this.TTL), "Duration", "types.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterTracepointResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTracepoints := "[]*RegisterTracepointResponse_TracepointStatus{"
	for _, f := range this.Tracepoints {
		repeatedStringForTracepoints += strings.Replace(fmt.Sprintf("%v", f), "RegisterTracepointResponse_TracepointStatus", "RegisterTracepointResponse_TracepointStatus", 1) + ","
	}
	repeatedStringForTracepoints += "}"
	s := strings.Join([]string{`&RegisterTracepointResponse{`,
		`Tracepoints:` + repeatedStringForTracepoints + `,`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterTracepointResponse_TracepointStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterTracepointResponse_TracepointStatus{`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetTracepointInfoRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForIDs := "[]*UUID{"
	for _, f := range this.IDs {
		repeatedStringForIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForIDs += "}"
	s := strings.Join([]string{`&GetTracepointInfoRequest{`,
		`IDs:` + repeatedStringForIDs + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetTracepointInfoResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTracepoints := "[]*GetTracepointInfoResponse_TracepointState{"
	for _, f := range this.Tracepoints {
		repeatedStringForTracepoints += strings.Replace(fmt.Sprintf("%v", f), "GetTracepointInfoResponse_TracepointState", "GetTracepointInfoResponse_TracepointState", 1) + ","
	}
	repeatedStringForTracepoints += "}"
	s := strings.Join([]string{`&GetTracepointInfoResponse{`,
		`Tracepoints:` + repeatedStringForTracepoints + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetTracepointInfoResponse_TracepointState) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForStatuses := "[]*Status{"
	for _, f := range this.Statuses {
		repeatedStringForStatuses += strings.Replace(fmt.Sprintf("%v", f), "Status", "statuspb.Status", 1) + ","
	}
	repeatedStringForStatuses += "}"
	s := strings.Join([]string{`&GetTracepointInfoResponse_TracepointState{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`Statuses:` + repeatedStringForStatuses + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ExpectedState:` + fmt.Sprintf("%v", this.ExpectedState) + `,`,
		`SchemaNames:` + fmt.Sprintf("%v", this.SchemaNames) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RemoveTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RemoveTracepointRequest{`,
		`Names:` + fmt.Sprintf("%v", this.Names) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RemoveTracepointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RemoveTracepointResponse{`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateConfigRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateConfigRequest{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`AgentPodName:` + fmt.Sprintf("%v", this.AgentPodName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateConfigResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateConfigResponse{`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetScriptsRequest{`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptsResponse) String() string {
	if this == nil {
		return "nil"
	}
	keysForScripts := make([]string, 0, len(this.Scripts))
	for k, _ := range this.Scripts {
		keysForScripts = append(keysForScripts, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForScripts)
	mapStringForScripts := "map[string]*cvmsgspb.CronScript{"
	for _, k := range keysForScripts {
		mapStringForScripts += fmt.Sprintf("%v: %v,", k, this.Scripts[k])
	}
	mapStringForScripts += "}"
	s := strings.Join([]string{`&GetScriptsResponse{`,
		`Scripts:` + mapStringForScripts + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddOrUpdateScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddOrUpdateScriptRequest{`,
		`Script:` + strings.Replace(fmt.Sprintf("%v", this.Script), "CronScript", "cvmsgspb.CronScript", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddOrUpdateScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddOrUpdateScriptResponse{`,
		`}`,
	}, "")
	return s
}
func (this *DeleteScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteScriptRequest{`,
		`ScriptID:` + strings.Replace(fmt.Sprintf("%v", this.ScriptID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteScriptResponse{`,
		`}`,
	}, "")
	return s
}
func (this *SetScriptsRequest) String() string {
	if this == nil {
		return "nil"
	}
	keysForScripts := make([]string, 0, len(this.Scripts))
	for k, _ := range this.Scripts {
		keysForScripts = append(keysForScripts, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForScripts)
	mapStringForScripts := "map[string]*cvmsgspb.CronScript{"
	for _, k := range keysForScripts {
		mapStringForScripts += fmt.Sprintf("%v: %v,", k, this.Scripts[k])
	}
	mapStringForScripts += "}"
	s := strings.Join([]string{`&SetScriptsRequest{`,
		`Scripts:` + mapStringForScripts + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetScriptsResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetScriptsResponse{`,
		`}`,
	}, "")
	return s
}
func (this *ExecutionStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecutionStats{`,
		`ExecutionTimeNs:` + fmt.Sprintf("%v", this.ExecutionTimeNs) + `,`,
		`CompilationTimeNs:` + fmt.Sprintf("%v", this.CompilationTimeNs) + `,`,
		`BytesProcessed:` + fmt.Sprintf("%v", this.BytesProcessed) + `,`,
		`RecordsProcessed:` + fmt.Sprintf("%v", this.RecordsProcessed) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RecordExecutionResultRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RecordExecutionResultRequest{`,
		`ScriptID:` + strings.Replace(fmt.Sprintf("%v", this.ScriptID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1) + `,`,
		`Result:` + fmt.Sprintf("%v", this.Result) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RecordExecutionResultRequest_Error) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RecordExecutionResultRequest_Error{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "statuspb.Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RecordExecutionResultRequest_ExecutionStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RecordExecutionResultRequest_ExecutionStats{`,
		`ExecutionStats:` + strings.Replace(fmt.Sprintf("%v", this.ExecutionStats), "ExecutionStats", "ExecutionStats", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RecordExecutionResultResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RecordExecutionResultResponse{`,
		`}`,
	}, "")
	return s
}
func (this *GetAllExecutionResultsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetAllExecutionResultsRequest{`,
		`}`,
	}, "")
	return s
}
func (this *GetAllExecutionResultsResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForResults := "[]*GetAllExecutionResultsResponse_ExecutionResult{"
	for _, f := range this.Results {
		repeatedStringForResults += strings.Replace(fmt.Sprintf("%v", f), "GetAllExecutionResultsResponse_ExecutionResult", "GetAllExecutionResultsResponse_ExecutionResult", 1) + ","
	}
	repeatedStringForResults += "}"
	s := strings.Join([]string{`&GetAllExecutionResultsResponse{`,
		`Results:` + repeatedStringForResults + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetAllExecutionResultsResponse_ExecutionResult) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetAllExecutionResultsResponse_ExecutionResult{`,
		`ScriptID:` + strings.Replace(fmt.Sprintf("%v", this.ScriptID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1) + `,`,
		`Result:` + fmt.Sprintf("%v", this.Result) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_Error) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetAllExecutionResultsResponse_ExecutionResult_Error{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "statuspb.Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats{`,
		`ExecutionStats:` + strings.Replace(fmt.Sprintf("%v", this.ExecutionStats), "ExecutionStats", "ExecutionStats", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringService(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *SchemaRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SchemaRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SchemaResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Schema == nil {
				m.Schema = &schemapb.Schema{}
			}
			if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentInfoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentInfoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Info = append(m.Info, &AgentMetadata{})
			if err := m.Info[len(m.Info)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Agent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Agent == nil {
				m.Agent = &agentpb.Agent{}
			}
			if err := m.Agent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &agentpb.AgentStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CarnotInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CarnotInfo == nil {
				m.CarnotInfo = &distributedpb.CarnotInfo{}
			}
			if err := m.CarnotInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentUpdatesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentUpdatesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentUpdatesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUpdateInterval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxUpdateInterval == nil {
				m.MaxUpdateInterval = &types.Duration{}
			}
			if err := m.MaxUpdateInterval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUpdatesPerResponse", wireType)
			}
			m.MaxUpdatesPerResponse = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxUpdatesPerResponse |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AgentID == nil {
				m.AgentID = &uuidpb.UUID{}
			}
			if err := m.AgentID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Update = &AgentUpdate_Deleted{b}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Agent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &agentpb.Agent{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &AgentUpdate_Agent{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &messagespb.AgentDataInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &AgentUpdate_DataInfo{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentUpdatesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentUpdatesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentUpdatesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentUpdates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AgentUpdates = append(m.AgentUpdates, &AgentUpdate{})
			if err := m.AgentUpdates[len(m.AgentUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentSchemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AgentSchemas = append(m.AgentSchemas, &distributedpb.SchemaInfo{})
			if err := m.AgentSchemas[len(m.AgentSchemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentSchemasUpdated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AgentSchemasUpdated = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndOfVersion", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EndOfVersion = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WithPrefixKeyRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WithPrefixKeyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WithPrefixKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Prefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proto", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proto = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WithPrefixKeyResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WithPrefixKeyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WithPrefixKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kvs = append(m.Kvs, &WithPrefixKeyResponse_KV{})
			if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WithPrefixKeyResponse_KV) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KV: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KV: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTracepointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterTracepointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterTracepointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, &RegisterTracepointRequest_TracepointRequest{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTracepointRequest_TracepointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointDeployment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TracepointDeployment == nil {
				m.TracepointDeployment = &logicalpb.TracepointDeployment{}
			}
			if err := m.TracepointDeployment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TTL == nil {
				m.TTL = &types.Duration{}
			}
			if err := m.TTL.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTracepointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterTracepointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterTracepointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tracepoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tracepoints = append(m.Tracepoints, &RegisterTracepointResponse_TracepointStatus{})
			if err := m.Tracepoints[len(m.Tracepoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTracepointResponse_TracepointStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTracepointInfoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetTracepointInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTracepointInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IDs = append(m.IDs, &uuidpb.UUID{})
			if err := m.IDs[len(m.IDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTracepointInfoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetTracepointInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTracepointInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tracepoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tracepoints = append(m.Tracepoints, &GetTracepointInfoResponse_TracepointState{})
			if err := m.Tracepoints[len(m.Tracepoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTracepointInfoResponse_TracepointState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= statuspb.LifeCycleState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Statuses = append(m.Statuses, &statuspb.Status{})
			if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpectedState", wireType)
			}
			m.ExpectedState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpectedState |= statuspb.LifeCycleState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaNames = append(m.SchemaNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveTracepointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveTracepointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveTracepointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Names = append(m.Names, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveTracepointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveTracepointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveTracepointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateConfigRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentPodName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AgentPodName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateConfigResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateConfigResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scripts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Scripts == nil {
				m.Scripts = make(map[string]*cvmsgspb.CronScript)
			}
			var mapkey string
			var mapvalue *cvmsgspb.CronScript
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthService
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthService
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthService
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &cvmsgspb.CronScript{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Scripts[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddOrUpdateScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddOrUpdateScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddOrUpdateScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Script", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Script == nil {
				m.Script = &cvmsgspb.CronScript{}
			}
			if err := m.Script.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddOrUpdateScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddOrUpdateScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddOrUpdateScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScriptID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScriptID == nil {
				m.ScriptID = &uuidpb.UUID{}
			}
			if err := m.ScriptID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetScriptsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetScriptsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetScriptsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scripts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Scripts == nil {
				m.Scripts = make(map[string]*cvmsgspb.CronScript)
			}
			var mapkey string
			var mapvalue *cvmsgspb.CronScript
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthService
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthService
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthService
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &cvmsgspb.CronScript{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Scripts[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetScriptsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetScriptsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetScriptsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecutionStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExecutionStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecutionStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionTimeNs", wireType)
			}
			m.ExecutionTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExecutionTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompilationTimeNs", wireType)
			}
			m.CompilationTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompilationTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesProcessed", wireType)
			}
			m.BytesProcessed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesProcessed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordsProcessed", wireType)
			}
			m.RecordsProcessed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordsProcessed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecordExecutionResultRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordExecutionResultRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordExecutionResultRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScriptID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScriptID == nil {
				m.ScriptID = &uuidpb.UUID{}
			}
			if err := m.ScriptID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &statuspb.Status{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &RecordExecutionResultRequest_Error{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExecutionStats{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &RecordExecutionResultRequest_ExecutionStats{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecordExecutionResultResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordExecutionResultResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordExecutionResultResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetAllExecutionResultsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetAllExecutionResultsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetAllExecutionResultsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetAllExecutionResultsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetAllExecutionResultsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetAllExecutionResultsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Results = append(m.Results, &GetAllExecutionResultsResponse_ExecutionResult{})
			if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetAllExecutionResultsResponse_ExecutionResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExecutionResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecutionResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScriptID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScriptID == nil {
				m.ScriptID = &uuidpb.UUID{}
			}
			if err := m.ScriptID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &statuspb.Status{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &GetAllExecutionResultsResponse_ExecutionResult_Error{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExecutionStats{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &GetAllExecutionResultsResponse_ExecutionResult_ExecutionStats{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipService(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowService
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthService
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupService
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthService
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthService        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
)
